1 overview of c++ cs3304 - data structure. 2 value parameters int abc (int a, int b, int c) // a, b,...

1

Overview of C++

CS3304 - Data Structure

2

Value parameters• Value parameters

int abc (int a, int b , int c) // a, b, and c are the

{ // formal parameters

a = a * 2;

return a+b+c;

}

call:

z = abc(2, x, y) //2, x, y are the actual parameters

3

Template Functionsfloat abc (float a, float b, float c) {

a = 2 * a;

return a+b+c;

}

template <class T>

T abc(T a, T b, T c) {

a = 2 * a;

return a+b+c;

}

4

Reference Parametersfloat abc(int& a, int& b, int& c) {

a = 2 * a;

return a+b+c;

}

template <class T>

T abc (T& a, T& b, T& c) {

a = 2 * a;

return a+b+c;

}

5

Const Reference Parameters• Formal parameters are not changed, avoid copying

template < class T>

T abc (const T& a, const T& b, cont T& c) {

return a+b+c;

}

template <class Ta, class Tb, class Tc>

Ta abc(const Ta& a, const Tb& b, const Tc& c) {

return a+b+c

}

6

Return Values• Value return

T X(int i, T& z) // a copy of the value is returned

• reference return

T& X(int i, T& z) //a reference is returned

• const reference return

const T& X(int i, T& z) // a reference to a const

// object is returned

7

Recursive functions

When a function calls itself (directly or indirectly).

ex: factorial, exponentiation, and Fibonacci numbers

n! = 1 * 2 * 3 * ... *n, for n > 0

and that 0! = 1

a recursive function has two parts:

base part

recursive part

8

ex: Factorial

n! = 1 if n = 0 (base)n! = n(n-1)! if n > 0 (recursive)

9

Definition• Recursion is a problem solving tool that allows you to solve a

problem p by solving another problem p' that is similar in nature to p but smaller.

• Each successive recursive call should bring you closer to a situation in which the answer is known.

• A case for which the answer is known (and can be expressed without recursion) is called a base case.

• Each recursive algorithm must have at least one base case, as well as the general (recursive) case

10

Factorial Nfactorial n n! = n * (n - 1) * (n - 2) * ... * 2 * 1;

int function fact (int n)

{

if (n == 0) // base case

return (1);

else // recursive case

return (n * fact (n - 1));

}

11

Steps

fact(4) -> 4 * fact(3) -> 3 * fact(2) -> 2 * fact(1) -> 1 * fact(0)

1 * 1

2 * 1 <-----------|

3 * 2 <-----------|

4 * 6 <------------|

24 <-------|

12

iterative solution to factorial

int function fact_it (int n )

{

int p;

p = 1;

for (int i = 1; i <= n; i++)

p = p * i;

return (p);

}

13

Disadvantages and Advantages of recursion

Disadvantages:

each function call creates an activation record in memory & requires processing time to set up records & to reset values after return from function call

advantages:

some problems may be easier to set up & program

14

Iterative function for SUM

Template <class T>

T sum(T a[], int n) {

//return sum of numbers a[0: n-1]

T tsum = 0;

for (int i = 0; i< n; i++)

tsum += a[i]

return tsum;

}

15

Recursive function for SUM

Template < calss T>

T Rsum(T a[], int n) {

// return sum of numbers a [0 : n-1]

if (n > 0)

return Rsum(a, n-1) + a[n-1]

return 0; // base case

}

16

Recursive function for the Fibonacci numbers

• F(0) = 0

• F(1) = 1

• F(n) = F(n-1) + F(n-2)

int fibonacci(int n) {

if (n==0) return 0;

else if (n==1) return 1;

else if (n > 1)

return (fibonacci(n-1) + fibonacci(n-2));

}

17

Dynamic Memory Allocation• Operator new

int *y;

y = new int;

*y = 10;

float *x = new float [n]; // array

• Operator delete

delete y;

delete [] x; // one-dimensional array

18

The operator new

int *y = new int;

*y = 10

or

int *y = new int (10)

or

int *y;

y = new int (10)

19

One-Dimensional Arrays

• Float *x = new float [n]

• addressing the elements:

– x[10], x[n-1]

20

Exception Handling• Using #Include <except.h>

• using try and catch

float *x;

try {x = new float [n];}

catch (xalloc) {// enter only when new fails

cerr << “out of Memory” << endl;

exit (1); }– xalloc exception is thrown by new when unable

to allocate memory memory

21

Two-dimensional ArraysChar c[7][5] // static allocation

• Dynamic allocation:

char (*c) [5] // number of columns=5

try {c = new char [n][5];} // n is a variable

catch (xalloc) { // enter only when new fails

cerr << “out of Memory” << endl;

exit (1); }

• Value of n may be determined dynamically

22

Two-dimensional Arrays• What if number of columns is not known at compile time?

• Need to construct array dynamically

• View 2-d array as a 1-d array of rows

• Each row is created using new

• Pointers to each row are saved in another

1-d array.

X

23

Pointer to Pointerstemplate <class T>

bool make2darray(T ** &x, int rows, int cols) {

try {

x = new T * [rows] // array of pointers

// create memory for each row

for (int i = 0, i <rows; i++)

x[i] = new int [cols]

return true

}

catch (xalloc) {return false;}

}

24

Classes

• Example: define a class currency

• $2.35

• -$64.32

• Operations:

– set data values

– determine components

– add two objects

– increment the value

– output

25

Classesenum sign (plus, minus);class Currency {

private:

sign sgn;

unsigned long dollars;

unsigned int cents; public:

Currency(sign s = plus, unsigned long d = 0,unsigned int c = 0);

~Currency() {}bool Set(sign s, unsigned long d,

unsigned int c);bool Set (float a);

26

Classes - cont.sign Sign() const {return sgn;}unsigned long Dollars() const {return dollars;}unsigned int Cents () cosnt {return cents;}Currency Add (const Currency& x) const;Currency& Increment (const Currency& x);void Output () const;

}

27

Classes - cont.

void main () {

Currency f;

currency g(plus, 2, 45), h(minus, 10);

Currency *m = new Currency (plus, 8, 12);

g.Set(minus, 33, 0);

h.Set(78.33);

}

28

Member Functions//Class constructor

Currency::Currency(sign s, unsigned long d,

unsigned int c)

{

if (c > 99) {

cerr << “Cents should be < 100” << endl;

exit (1);}

sgn = s; dollars = d; cents = c;

}

29

Member Functions - Cont.

Bool Currency::Set(sign s, unsigned long d,unsigned int c)

{if (c > 99 ) return false;sgn = s; dollars = d; cents = c;return true;

}

30

Member function -contBool Currency::Set (float a) {

if (a < 0) {sgn = minus; a = -a;}

else sgn = plus;

dollars = a;

cents = ( a + 0.005 – dollars) * 100;

return true;

}

//00.5 is needed to take care of computer errors when representing float numbers

31

Add

32

Member function -contCurrency& Currency::Increment(const Currency& x)

{

*this = Add(x);

return *this;

}

• this points to the invoking object

• *this is the invoking object

33

Operator Overloading• C++ built-in operators can be overloaded

• Overloaded operator obeys the precedence, associativity, and number of operands dictated by the built-in operator

• When an operator is overloaded as a member function, the object associated with the operator is the left-most operand

example: X + Y <=> X.operator + (Y)

=> left-most operand must be an object of the class of which the operator is a member.

If that is not the case, instead of using a member operator use a friend operator.

34

Operator Overloadingenum sign (plus, minus);class Currency {private:

sign sgn; unsigned long dollars; unsigned int cents;

public:Currency(sign s = plus, unsigned long d = 0,

unsigned int c = 0);~Currency() {}bool Set(sign s, unsigned long d,

unsigned int c);bool Set (float a);

35

Operator Overloadingsign Sign() const {return sgn;}unsigned long Dollars() const {return dollars;}unsigned int Cents () cosnt {return cents;}Currency operator+ (const Currency& x) const;Currency& Increment (const Currency& x);void Output () const;

}

36

Operator OverloadingCurrency Currency::operator+ (const Currency& x) const {

Currency y;

y.amount = amount + x.amount;

return y;

}

Example:

Currency A(2, 50), B(minus, 7, 35), C;

C = A + B;

37

Operator Overloadingvoid Currency :: output() const

{

if (sgn == minus) cout << ‘-’;

cout << ‘$’ << dollars << ‘.’;

if (cents < 10) cout << “0”;

cout << cents;

}

• Example: Currency X(plus, 3, 50);

X.output();

38

Operator Overloading

• Better overload the stream insertion operator <<:

cout << X;

• Note However,

cout.operator << X // erroneous

• the object from which the operator is invoked is not an object of type Currency.

==> operator << can NOT be a member of the class.

• Can define operator outside the class

==> no access to private members

• Define it as a friend member.

39

New Currency Classclass Currency {

friend ostream& operator<< (ostream&, const Currency&);

public:Currency()….Unsigned long Dollars() const{ if (amount < 0) return (-amount) / 100; else return amount / 100;}….

Private:long amount;

}

40

Member function -contostream& operator<< (ostream& out, const Currency& X)

{

if (X.sgn == minus) out << ‘-’;

out << ‘$’ << x.dollars << ‘.’;

if (X.cents < 10) out << “0”;

out << X.cents;

return out;

}

41

Friend Functions/Operators• A friend function is a function defined outside of the class scope.

Note: there is no scope resolution

• The keyword “friend” is used in the class specification

• A friend function of a class has access to the private members of the class

• Inside the function definition, the dot operator is required to access the class data members.

42

Classes with Dynamic Data Members

• Class constructor(s)

• Class destructor

• Class copy-constructor

• Class deep copy function member

43

Classes with Dynamic Data Members• The following member functions are needed

Class constructor(s) initializationallocate space for dynamic dataInvoked automatically when an object is created

Class destructor free space allocated for dynamic dataInvoked automatically when an object goes out of scope

Class copy-constructorneeded to do deep copying. Invoked automatically in the

following situationsInitialization at declarationAn object parameter is passed by valueAn object is the function return value

Class deep copy function member: Must be invoked explicitly

44

The Date Class Exampleclass Date {

public:

Date(int, int, int, char* ); // Constructor

Date(void ); // default Constructor

Date(const Date& ) // Copy-constructor

~Date( void); // Destructor

void DeepCopy (Date OtherDate); // Deep copy

….

void get(int&, int&, int&);

private:

int month, day, year;

char* msg; //pointer to char string

};

45

Class ConstructorsDate::Date(void ) //default constructor

{

day = 1; month = 1; year = 1;

msg = NULL; //msg points to NULL

}

Date::Date(int d, int m, int y, char* msgstr)

{

day = d; month = m; year = y;

//Allocate memory for a new string of char

msg = new char[strlen(msgstr) + 1];

//copy msgstr into msg

strcpy(msg, msgstr);

}

46

Class Constructors class Date {

public:

Date(int =1, int =1, int =1, char* =NULL );

//Constructor with default parameters

Date(const Date& ) // Copy-constructor

~Date(void ); // Destructor

void DeepCopy (Date OtherDate); //Deep copy

void get(int&, int&, int&);

private:

int month, day, year;

char* msg; //pointer to char string

};

47

Class Constructors

Example: Date X, Y(10, 5, 1995);

Date Z(9, 2, 2002, "Labor Day");

Date A[100];

• When declaring an array of objects, the default constructor is used to initialize each object in the array.

• If no default constructor (and no default parameters), the array objects will NOT be initialized.

48

Needed to do deep copying. Invoked automatically in the following situations:

Initialization at declaration

An object parameter is passed by value

An object is a function return value

Copy Constructor

49

Copy Constructorclass ClassName {

public:

………

ClassName(const ClassName& SomeObject);private:

………

};

A copy constructor is needed only if some data members are dynamic data

The name of the constructor is the same as the name of the class

The parameter is a reference to an object of the class type.

50

Date Copy-Constructor

//Implementation of Date copy-constructor

Date::Date(const Date& OtherDate)

{

// copy static data members

month = OtherDate.month; day = OtherDate.day;

year = OtherDate.year;

//copy dynamic data member

msg = new char[strlen(OtherDate.msg)+1];

strcpy(msg, OtherDate.msg);

}

Example: Date X(9, 2, 2002, "Labor Day");

Date Y= X; // Initialization at declaration

51

Class Destructor

Date::~Date(void)

{

// De-allocate data pointed to by msg.

delete [ ] msg;

}

• Invoked automatically when an object gets out of scope

• Needed when a class uses dynamic data members to de-allocate memory

52

Deep vs. Shallow Copying of Dynamic Data Members

• What happens when the following function is executed?

#include "date.h"

int main( void)

{

Date D1(10,10,2002, “Al Birth Day”);

Date D2(2, 5, 1999, “Jane Birth Day”);

D1 = D2; // Assignment Requires copying

// D2 into D1

return 0;

}

53

Deep vs. Shallow Copying of Dynamic Data Members

void Date::DeepCopy(const Date& X)

{

// Copy static data members

day = X.day; month = X.month; year = X.year;

//Copy dynamic data members

delete [] msg; // deallocate the original string

msg = new char[strlen(X.msg) + 1]; // allocate space for new string

strcpy(msg, X.msg); // copy the X.msg in msg

}

Example: Date D1(10,10,1772, “Al Birth Day”);

Date D2(2, 5, 1999, “Jane Birth Day ”);

D1.DeepCopy( D2); // Assignment

54

Overloading the = operator with deep copy

class Date {

public:

Date(int=1, int=1, int=1, char* = 0 ); //Constructor

Date(const Date& ) // Copy-constructor

~Date( ); // Destructor

void operator = (Date OtherDate); // deep copy assignment

void get(int&, int&, int&);

private:

int month, day; year;

char* msg; //pointer to char string

};

55

Overloading the = operator with deep copy

void Date::operator = (Date X)

{

// Copy static data members

day = X.day; month = X.month; year = X.year;

//Copy dynamic data members

delete [] msg; // deallocate the original string

msg = new char[strlen(X.msg) + 1]; // space for new string

strcpy(msg, X.msg); // copy the X.msg in msg

}

56

Example: Date D1(10,10,1772, “Al Birth”);

Date D2(2, 5, 1999, “Jane Birth”);

D1 = D2;

57

More on C++• preprocessor

– to ensure that compilation is done only once

#ifndef Preprocessor_Identifier

#define Preprocessor_Identifier

class definition

#endif

58

Testing

To expose the presence of errors

• test data

• test set

• designing test data

– black box method

– white box method

59

White box methods

• statement coverage

• decision coverage

• clause coverage

• execution path coverage

60

Debugging suggestions

• logical reasoning

• program trace

• make sure the correction does not introduce new errors

• use incremental testing and debugging

61

End of Chapter 1