what is an aggregate construct? What aggregate constructs have we studied? what is a structure? what is the keyword to define a structure? what are structures used for? is a structure definition an executable statement? Can it be put in a header

file? why includeing a header file with structures definition multiple times is a

problem? how is this problem solved? what are #define #ifndef #endif? what is a structure variable? what is the term for elements of a structure? do elements of the same structure (different structures) have to have unique

names? how can structures be initialized? what happens when one structure variable

is assigned the value of another? can structure variables be directly compared? passed as parameters? by

value? by reference? can a function return a structure? can one structure be included in another structure? What is a substructure? can a structure include an array? how can an array of structures be declared?

Structures Revisited

1

Classes

structure is an aggregate construct providing encapsulation encapsulation - combining a number of items in a single entity consider implementing date:

as structure:struct Date{int month;int day;int year;

};

and a set of functions manipulating dates:void setDate(Date &d, int m, int d, int y);void addYear(Date &d, int n);bool compare(Date &d1, Date &d2);

problems: there is no explicit connection between data type (structure) and these

functions it does not specify that the functions listed should be the only ones that access

and modify date variables– if there is a bug in Date manipulation - it can be anywhere in the program– if modification of Date is needed - all program needs to be updated

What’s Wrong with Structures?

3

class is an aggregate construct class may contain member variables (attributes) and member functions (methods) member variables and member function prototypes are declared within class definition member functions can manipulate member variables without accepting them as

parameters

class Date { // class namepublic: // ignore this for now void set(int, int, int); int getDay();

int month;int day;int year;

}; // don’t forget the semicolon

a variable of type class is called object (how is a variable of type structure called?)Date mybday;

the object is said to belong to the class or be an instance of the class

each object has member variables and can call member functions of its class

values of all member variables is the state of the object

addressing the members is done using dot-operator:mybday.set(10, 26, 68);cout << mybday.day;

Class Definition

4

public/private attributes control the way the class members are accessed (why do we want to do that?)

public member can be accessed within member functions (no scope resolution needed) and outside (with dot operator)

private member - can only be accessed within member functions class Date { // class namepublic: void set(int, int, int); int getday();private:

int month;int day;int year;

}; // don’t forget semicolon

make member variables private, make functions either public or private. This restricts manipulation of variables to member function which makes debugging and changes in class easier

examples:

mybday.set(10, 5, 99); // good

mybday.year=99; // ERROR - private member

Public and Private Members

5

functions can be defined either inside or outside class definition

outside definition - class name (called type qualifier) and scope resolution operator (::) precedes function name:void Date::set(int m, int d, int y){

month=m; // no dot with member variablesday=d; // no declaration of member variables

year=y;}

to define inside - replace prototype with definition

class Date {public: void set(int, int, int); int getDay(){return day;}private:

int month;int day;int year;

}; // don’t forget semicolon

function defined inside is called in-line function

for style: use for very small functions. One line is good

Member Function Definitions

6

accessor function - member function that does not modify the state of an object (only returns the information about the object’s state)

mutator function - member function that modifies the state of an object accessors should be marked with const type modifier so that compiler can find

accidental object state modification

also remember to use const with parameters that are not modified

class Date {public: // mutator void set(int, int, int); // mutator int getMonth() const; // accessor int getDay() const {return(day);} // accessor in-lineprivate:

int month;int day;int year;

};

separate mutators and accessors - a function should not do both since variables are private they all need accessor are we missing an accessor in Date?

Mutators and Accessors

7

constructor - mutator that is invoked automatically when object is declared used to assign an initial state to the object (initialize object)

constructor it has the same name as class constructor does not return a value

do not put void as a return value of constructor

class Date{public: Date(int, int, int); // constructorprivate:

int month, day, year;};

outside constructor definition (can also be inlined)Date::Date(int m, int d, int y){

month=m;day=d;

year=y;}

constructor is invoked at declaration: Date mybday(10,26,99); or directly: yourbday=Date(10,26,00);

Constructors

8

class can have multiple constructors which constructor to call is determined by number and type of arguments

function overloading – same name functions distinguished by number/type of arguments

it is bad style to define constructors that differ by type of arguments only - confusing if no constructors declared - object can be defined without initialization void (or default) constructor - a constructor that does not take arguments

caveat: if at least one constructor declared - object has to be always initialized (needs a void constructor)

class Date {public: Date(int, int, int); // constructor Date(int, int); // another constructor Date(); // void or default constructorprivate:

int month;int day;int year;

};

calling default constructor (if constructors defined): Date mybday; if array of objects, default constructor is invoked Date friendsbday[20]; what is this? Date mybday();

Multiple/Void Constructors

9

(void) constructors for member objects are invoked before constructor for containing object

example

class one{ public: one() { cout << ”one's constructor" << endl; };

};

class two{ public: two() { cout << ”two's constructor" << endl; };

private: one o;

};

int main() {

two ob2;

} prints

one’s constructortwo’s constructor

note, if containing object does not have a constructor, member object (void) constructors are still invoked

Constructors for Member Objects

10

to allow non-member function to access private class members it should be declared as friend function:class Date {public: // compares two dates friend bool equal(const Date&, const Date&);private:

int month;int day;int year;

}; a friend-function is not a class member - it’s definition should not be preceded with

type qualifier (Date::) no separate prototype (outside class definition) is necessary for friend equal is invoked as non-member function - without dot operator:

if(equal(date1, date2)) { ...

friend-functions circumvent information hiding and should be used as rare as possible and with great care

only use friend-function if the task requires access to private members of more

than one object and the objects are used symmetrically

Friend Functions

11

the scope of static constant is the class: it is available to all methods it is stored only once but every object of this class has access to it can be private or public

class Date {public:

...private: static const int CENT21 = 2001; ...

};

variables can also be declared static. Careful with those since they are in effect global variables (not as problematic, why?)

Static Constants

12

program with objects is laid out as follows: header - class definition (inline function definitions), global

constants and other non-executable constructs related to class program file - member function definitions

multiple related classes may be put in one header/program file pair

Program Layout

13

What is class? Why are classes needed? What is object? What is the difference between object and class? What do we mean when we

say object belongs to a class? What’s member variable? Member function? Method? Attribute? What’s an in-line function definition? What are these operators used for? “.” “::” What is the difference between public and private members of class? What is the state of an object? What is mutator? Accessor? How is accessor function distinguished? What is constructor? Is constructor mutator or accessor? What is the name of constructor? How many parameters can constructor take? Can there be more than one

constructor? What is constructor overloading? What is void constructor? What is the return value of constructor? What is friend function? Why is it needed? What are static attributes?

Classes Review

14