1. Structures Revisited
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?

2. aggregating code and data
Classes
aggregating code and data

3. What’s Wrong with Structures?
modular program – easily separatable into independent parts
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
the program is usually not modular

4. Class Definition
class is an aggregate construct combining related code and data
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 name
public: // 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
state of the object – values of all member variables
accessing members is done using dot-operator:
mybday.set(10, 26, 68);
cout << mybday.day;

5. Public and Private Members
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 name
public:
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

6. Member Function Definitions
member functions can be defined either inside or outside class definition
outside definition (or out-of-line) - class name (called type qualifier) and scope resolution operator (::) precede function name:
void Date::set(int m, int d, int y){
month=m; // no dot with member variables
day=d; // no declaration of member variables
year=y; }
inside definition (or in-line) - replace prototype with definition, no trailing semicolon necessary
class Date {
public:
void set(int, int, int);
int getDay(){return day;} // note no semicolon
private:
int month;
int day;
int year;
}; // don’t forget semicolon
for style: use for very small functions – one line is good

7. Mutators and Accessors
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-line
private:
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?

8. Classes with Member Objects
member variables may be basic types or objects of other classes
class Meeting{
pubic:
void setDate(int, int, int);
private:
Date d;
Time t; };
member objects may be manipulated through pubic methods only
void Meeting::setDate(int m, int d, int y){
d.set(m,d,y); // invokes public member of Date
d.month = m; // error, cannot access private members
// of Date }

9. Constructors
function invocation: explicit – if function name is mentioned, implicit - otherwise
constructor - mutator that is invoked implicitly when object is declared
used for object initialization
constructor has the same name as class
constructor does not return a value
do not put void as a return type of constructor
class Date{
public:
Date(int, int, int); // constructor
private:
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; }
invocation at declaration: Date mybday(10,26,99);

10. Multiple/Void Constructors
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
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 constructor
private:
int month;
int day;
int year; };
invoking default constructor (if constructors defined): Date mybday;
if array of objects, default constructor is invoked Date friendsbday[20];

11. Initializer List constructors can be defined with initializer list:
syntax
functionName (parameter list): memberVar(param), … {body (possibly empty)}
example
class Date {
public:
// inline constructor definition with initializer list
Date(int m, int d, int y): month(m), day(d), year(y) {}
Date(int, int);
Date();
private:
int month;
int day;
int year; };
// outside constructor definition with initializer list
Date::Date(int m, int d): month(m), day(d), year(2001) {}
how would you define the default constructor with initializer list?

12. Constructors for Member Objects
(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 constructor Two’s constructor
note, if containing object does not have a constructor, member object (void) constructors are still invoked

13. Initializers for Member Objects
initializer for member object invokes it’s constructor
example
class One{ public:
One(int p): p_(p){}
private:
p_; };
class Two{ public:
Two(int o): o_(o) {}; // o_’s constructor invoked
One o_; // member object
int main() {
Two ob2(5); // object declaration }

14. Friend Functions
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 with care
use friend-function if the task requires access to private members of more than one object and the objects are used symmetrically

15. Member Constants
constant declared inside the class is only available to class members
good way to limit its scope
can be private or public
static shared between all objects of the class
example
class Date {
public:
...
private:
static const int cent21 = 2001; };

16. Program Layout 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

17. Classes Review 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/out 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?
What is implicit/explicit function invocation?
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 initializer list
What is friend function? Why is it needed?
Why are constants declared inside class definitions?