starting out with c++, 3 rd edition 1 chapter 14: more about classes static members if a member...

1

Starting Out with C++, 3rd Edition

Chapter 14: more about classesStatic Members

• If a member variable is declared static, all objects of that class have access to a single instance of that variable.

• If a member function is declared static, it may be called before any instances of the class are defined and it may only use static variables.

2


Member Variable is Staticint Y;static int X;

3


budget.h – Program #ifndef BUDGET_H#define BUDGET_Hclass Budget{ private:

static float corpBudget;float divBudget;

public:Budget ( void ) { divBudget = 0; }void addBudget ( float b ) { divBudget += b; corpBudget += divBudget; }float getDivBudget ( void ) { return divBudget; }float getCorpBudget ( void ) { return corpBudget; }

}; // Budget#endif

budget.cpp – odd way to initializefloat Budget::corpBudget = 250000;

4


Static Member Functions

• The syntax for a static member function is:static <return type><function name>(<parameter list>);– A class’s static member variables come into existence

before any instances of the class are created.– The static member functions use only static variables

and are callable before any instances of the class are created..

5


A New budget.h – Program #ifndef BUDGET_H#define BUDGET_Hclass Budget{ private:

static float corpBudget; float divBudget;

public: … static void mainOffice ( float );

}; // Budget#endif

6


budget.cpp – Program

#include "budget.h"

float Budget::corpBudget = 0;

void Budget::mainOffice ( float moffice ){ corpBudget += moffice;} // Budget::mainOffice

7


Using budget.h – Program

#include <iostream.h>#include <iomanip.h>#include "budget.h"

void main ( void ){ float amount;

cout << "Enter the main office's budget request: ";cin >> amount;Budget::mainOffice(amount);…

8


Friends of Classes

• A friend is a function that is not a member of a class, but has access to the private members of the class.

• The syntax of a friend function is as follows and is included in the .h file for the class:friend <return type><function name>(<parameter type list>);

9


auxil.h – Program #ifndef AUXIL_H#define AUXIL_H

class Budget; // Forward declaration of Budget class

class Aux{ private:

float auxBudget; public:

Aux ( void ) { auxBudget = 0; } void addBudget ( float, Budget & ); float getDivBudget ( void ) { return auxBudget; }

}; // Aux#endif

10


budget.h – Program

#ifndef BUDGET_H#define BUDGET_H#include "auxil.h"class Budget{ private:

static float corpBudget; float divBudget;

public: Budget ( void ) { divBudget = 0; } void addBudget ( float b )

{ divBudget += b; corpBudget += divBudget; } float getDivBudget ( void ) { return divBudget; } float getCorpBudget ( void ) { return corpBudget; } static void mainOffice ( float ); friend void Aux::addBudget ( float, Budget & );

}; // Budget#endif

11


Friend Classes

• As mentioned before, it is possible to make an entire class a friend of another class.

• The Budget class could make the Aux class its friend with the following declaration: friend class Aux;

• Note – generally a “friend” is bad as it violates the encapsulation principle.

12


Memberwise Assignment

• The = operator may be used to assign one object to another, or to initialize one object with another object’s data.

• By default, each member of one object is copied to its counterpart in the other object.

13


Copy Constructors

• A copy constructor is a special constructor, called whenever a new object is created and initialized with another object’s data.

• Assume the class Set has a member variable as follows: bool *member which is dynamically allocated.

• Consider the following declarations:– Set x(5,15); // 15 possible members, 5 is a member– Set y = x; // Copy constructor is calledbut – is only a shallow copy, so when set y changes, set

x does to

14


The Default Copy Constructor

• If a class doesn’t have a copy constructor, C++ automatically creates a default copy constructor.

• The default copy constructor performs a memberwise assignment.

15


The this Pointer

• *this is a special built-in pointer that is available in any member function.

• *this contains the address of the object that called the member function. It is the name for ME.

16


Operator Overloading

• C++ allows you to redefine how standard operators work when used with class objects.

17


Issues of Operator Overloading

• You can change an operator’s entire meaning when you overload it. (But don’t.)

• You cannot change the number of operands taken by an operator. For example, the + symbol must always be a binary operator. Likewise, ++ and -- must always be unary operators.

18


Operators That can be Overloaded

+ - * / % ^ & | ~ ! = <

> += -= *= /= %= ^= &= |= << >> >>=

< == != <= >= && || ++ -- ->* , ->

[] () new delete

19


Because our unionSet has same arguments and return value as +, we can simply make a name change:

Set & Set::operator+(Set & arg2){ Set *res; int min; if(memberMax>arg2.memberMax){

min=arg2.memberMax; res = new Set(*this);

} else { res = new Set(arg2); min = memberMax;

} for (int i=0; i < min; i++)

res->member[i]= arg2.member[i] || member[i]; return *res; };

20


Overloading the Prefix ++ OperatorSet & Set::operator++(void){

bool * member1 = new bool[memberMax+1];

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

member1[i] = member[i];

delete [] member;

member = member1;

member[memberMax]=false;

memberMax++;

return *this;

}

21


Overloading the Postfix ++ OperatorSet &Set::operator++(int x){// parameter is never used!

bool * member1 = new bool[memberMax+1];

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

member1[i] = member[i];

delete [] member;

member = member1;

member[memberMax]=false;

memberMax++;

return *this;

}

22


Overloading Relational Operatorsbool Set::operator<(Set & arg2){// subset for us

int min = memberMax;

if (arg2.memberMax < min)

min = arg2.memberMax;

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

if (member[i] && !arg2.member[i]) return false;

if (memberMax >min)

for (i=min; i < memberMax;i++)

if (member[i]) return false;

return true;

}

23


Overloading the == Operator

bool Set::operator==(Set & arg2){

if (memberMax!=arg2.memberMax) return false;

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

if (member[i]!=arg2.member[i]) return false;

return true;

}

24


Overloading the << Operator

Note – this cannot be a member function of Set as the first argument is not a Set

ostream &operator<< ( ostream &strm, Set &obj ){ strm << “Whatever I want”; strm<< “ – but be careful about member

variables”; strm << “Since I’m not a member, I can’t access

them”;} // operator<<

25


Overloading the >> Operator

istream &operator>> ( istream &strm, Set &obj ){int ele; strm >> ele; Set.addToSet(x); //or make friend or use input()

member} // operator>>

26


Overloading the [] Operator

• In addition to the traditional operators, C++ allows you to change the way the [] (subscript) symbols work.

27


intarry.h – Program #ifndef INTARRY_H#define INTARRY_HClass IntArray{ private:

int *aptr;int arraySize;void memError ( void );void subError ( void );

public:IntArray ( int );IntArray ( const IntArray & );~IntArray ( void );int size ( void ) { return arraySize };int &operator[] ( const int & );

}; // IntArray#endif

28


intarray.cpp – Program IntArray::IntArray ( int s ){ arraySize = s; aptr = new int [s]; if ( aptr == NULL )

memError(); for ( int count = 0; count < arraySize; count++ )

*( aptr + count ) = 0;} // IntArray::IntArray

IntArray::IntArray ( const IntArray &obj ){ arraySize = obj.arraySize; aptr = new int [arraySize]; if ( aptr == NULL )

memError(); for ( count = 0; count < arraySize; count ++ ) *( aptr + count ) = *( obj.aptr + count );} // IntArray::IntArray

29


intarray.cpp – Program (cont)

IntArray::~IntArray ( void ){ if ( arraySize > 0 )

delete [] aptr;} // IntArray::~IntArray

void IntArray::memError ( void ){ cout << "ERROR: Cannot allocate memory.\n"; exit( 1 );} IntArray::memError

30


intarray.cpp – Program (cont)

void IntArray::subError ( void ){ cout << "ERROR: Subscript out of range.\n"; exit( 1 );} // IntArray::subError

int &IntArray::operator[] ( const int &sub ){ if ( sub < 0 || sub > arraySize )

subError(); return aptr[sub];} // IntArray::operator[]

31


Object Conversion via overloading

• Special operator functions may be written to convert a class object to any other type.FeetInches::operator float ( void )

{ float temp = feet;temp += (inches / 12.0);return temp;

} // FeetInches::operator float

32


Note:

• No return type is specified in the function header for the previous example.

• Because it is a FeetInches-to-float conversion function, it will always return a float.

starting out with c++, 3 rd edition 1 chapter 14: more about classes static members if a member...

Documents