Transcript Document 7612231

Chapter 2
C++ Class
•
•
•
•
A class name
Data members
Member functions
Levels of program access
– Public: section of a class can be accessed by
anyone
– Private: section of a class can only be accessed
by member functions and friends of that class
– Protected: section of a class can only be
accessed by member functions and friends of
that class, and by member functions and
friends of derived classes
Definition of the C++ class Rectangle
Program 2.2 Implementation of
operations on Rectangle
// In the source file Rectangle.C
#include “Rectangle.h”
// The prefix “Rectangle::” identifies GetHeight() and GetWidth() as member
functions belong to class Rectangle. It is required because the member
functions are implemented outside their class definition
int Rectangle::GetHeight() {return h;}
int Rectangle::GetWidth() {return w;}
Constructor and Destructor
• Constructor: is a member function which
initializes data members of an object.
– Adv: all class objects are well-defined as soon as they
are created.
– Must have the same name of the class
– Must not specify a return type or a return value
• Destructor: is a member fucntion which deletes
data members immediately before the object
disappears.
– Must be named identical to the name of the class
prefixed with a tilde ~.
– It is invoked automatically when a class object goes out
of scope or when a class object is deleted.
Constructors for Rectangle
Rectangle r(1, 3, 6, 6);
Rectangle *s = new Rectangle(0, 0, 3, 4);
Rectangle t;
Operator Overloading
• C++ can distinguish the operator ==
when comparing two floating point
numbers and two integers. But what if
you want to compare two Rectangles?
Array
• Is it necessary to define an array as
an ADT?
– C++ array requires the index set to be a
set of consecutive integers starting at 0
– C++ does not check an array index to
ensure that it belongs to the range for
which the array is defined.
ADT 2.1 GeneralArray
ADT 2.2 Polynomial
Polynomial Representations
Representation 1
private:
int degree;
// degree ≤ MaxDegree
float coef [MaxDegree + 1];
Representation 2
private:
int degree;
float *coef;
Polynomial::Polynomial(int d)
{
degree = d;
coef = new float [degree+1];
}
Polynomial Representation 3
class Polynomial; // forward delcaration
class term {
friend Polynomial;
private:
float coef;
int exp;
};
// coefficient
// exponent
private:
static term termArray[MaxTerms];
static int free;
int Start, Finish;
term Polynomial:: termArray[MaxTerms];
Int Polynomial::free = 0; // location of next free location in temArray
Representation 3 for two Polynomials
Represent the following two polynomials:
A(x) = 2x1000 + 1
B(x) = x4 + 10x3 + 3x2 + 1
Polynomial Addition
O(m+n)
Adding a new Term
Disadvantages of Representing
Polynomials by Arrays
• What should we do when free is going to
exceed MaxTerms?
– Either quit or reused the space of unused
polynomials. But costly.
• If use a single array of terms for each
polynomial, it may alleviate the above issue
but it penalizes the performance of the
program due to the need of knowing the
size of a polynomial beforehand.
Sparse Matrices
3
4
 27
 6

82

2


 109  64 11 


12
8
9


 48
27 47 
15
0

0

0
91

 0
22 0  15
11 3 0 0 0 
0 0 6 0 0 

0 0 0 0 0 
0 0 0 0 0 

0 28 0 0 0 
0
0
ADT 2.3 SparseMatrix
Sparse Matrix Representation
• Use triple <row, column, value>
• Store triples row by row
• For all triples within a row, their
column indices are in ascending order.
• Must know the number of rows and
columns and the number of nonzero
elements
Sparse Matrix Representation (Cont.)
class SparseMatrix; // forward declaration
class MatrixTerm {
friend class SparseMatrix
private:
int row, col, value;
};
In class SparseMatrix:
private:
int Rows, Cols, Terms;
MatrixTerm smArray[MaxTerms];
Transposing A Matrix
• Intuitive way:
for (each row i)
take element (i, j, value) and store it in (j, i, value)
of the transpose
• More efficient way:
for (all elements in column j)
place element (i, j, value) in position (j, i, value)
Transposing a Matrix
O(terms*columns)
Fast Matrix Transpose
• The O(terms*columns) time =>
O(rows*columns2) when terms is the
order of rows*columns
• A better transpose function
– It first computes how many terms in each
columns of matrix a before transposing to
matrix b. Then it determines where is the
starting point of each row for matrix b.
Finally it moves each term from a to b.
O(columns)
O(terms)
O(columns-1)
O(terms)
O(row * column)
Matrix Multiplication
• Definition: Given A and B, where A is mxn
and B is nxp, the product matrix Result
has dimension mxp. Its [i][j] element is
n 1
result ij   aijbkj
k 0
for 0 ≤ i < m and 0 ≤ j < p.
Matrix Multiplication
Representation of Arrays
• Multidimensional arrays are usually
implemented by one dimensional array
via either row major order or column
major order.
• Example: One dimensional array
Two Dimensional Array Row
Major Order
Col 0 Col 1
Col 2
Col u2 - 1
Row 0
X
X
X
X
Row 1
X
X
X
X
Row u1 - 1
X
X
X
X
u2
elements
Row 0
u2
elements
Row 1
i * u2 element
Row i
Row u1 - 1
Generalizing Array
Representation
The address indexing of Array A[i1][i2],…,[in]
is
α+ i1 u2 u3 … un
+ i2 u3 u4 … un
+ i3 u4 u5 … un
:
:
+ in-1 un
+ in
n
=α+  i j a j
j 1
where
n

1 j  n
a j   u k

k  j 1

an  1
String
• Usually string is represented as a
character array.
• General string operations include
comparison, string concatenation,
copy, insertion, string matching,
printing, etc.
H
e
l
l
o
W
o
r
l
d
\0
String Matching The KnuthMorris-Pratt Algorithm
• Definition: If p = p0p1…pn-1 is a pattern, then its
failure function, f, is defined as
largest
f ( j)  
 1
k  j such that p0 p1... pk  p j k p j k 1... p j
if such a k  0 exists
otherwise .
• If a partial match is found such that si-j … si-1 =
p0p1…pj-1 and si ≠ pj then matching may be resumed
by comparing si and pf(j–1)+1 if j ≠ 0. If j = 0, then we
may continue by comparing si+1 and p0.
Fast Matching Example
Suppose exists a string s and a pattern pat = ‘abcabcacab’, let’s
try to match pattern pat in string s.
j
0 1 2 3 4 5 6 7 8 9
pat a b c a b c a c a b
f
-1 -1 -1 0 1 2 3 -1 0 1
s = ‘- a b c a ? ? . . . ?’
pat = ‘a b c a b c a c a b’
j = 4, pf(j-1)+1 = p1
‘a b c
a b c
a c a b’
New start matching point