oop Lecture 11

Object Oriented Programming

Lecture 11 – Objects and Classes
Robert Lafore, 3rd ed., Chapter 6 (contd..)

Engr. M. Anwar-ul-Haq

Constructor
• we can rewrite the constructor to print a
message when it executes.
Counter() : count(0)
{ cout << “I’m the constructorn”; }

OOP Spring 2011, Engr. Anwar, Foundation University (FUIEMS), Rawalpindi
2

Destructor
• A special member function—the constructor—is
called automatically when an object is first
created. Another function is called automatically
when an object is destroyed. This is indeed the
case. Such a function is called a destructor.

• A destructor has the same name as the constructor
(which is the same as the class name) but is
preceded by a tilde
3

Destructor
class Foo
{
private:
int data;

public:
Foo() : data(0) //constructor (same name as class)
{}

~Foo() //destructor (same name with tilde)
{}
};

4

Destructor
• Like constructors, destructors do not have a return
value.

• They also take no arguments (the assumption
being that there’s only one way to destroy an
object).

• The most common use of destructors is to
deallocate memory that was allocated for the
object by the constructor.

5

Objects as Function Arguments
• Here we demonstrates some new aspects of
classes: constructor overloading, defining
member functions outside the class, and—
perhaps most importantly—objects as
function arguments.

6

Example
class Distance
{
private:
int feet;
float inches;
public: //constructor (no args)
Distance() : feet(0), inches(0.0) { }
Distance(int ft, float in) : feet(ft), inches(in) //constructor (two args)
{}
void getdist()
{
cout << “nEnter feet: ”; cin >> feet;
cout << “Enter inches: ”; cin >> inches;
}
void showdist() //display distance
{ cout << feet << “’–” << inches << ‘”’; }
void add_dist( Distance, Distance ); //declaration
};

7

Example
void Distance::add_dist(Distance d2, Distance d3)
{
inches = d2.inches + d3.inches;
feet = 0;
If (inches >= 12.0)
{
inches –= 12.0; //by 12.0 and
feet++; //increase feet
}
feet += d2.feet + d3.feet;
}

8

Example
int main()
{
Distance dist1, dist3;
Distance dist2(11, 6.25);
dist1.getdist();
dist3.add_dist(dist1, dist2);

cout << “ndist1 = ”; dist1.showdist();

return 0;
}
9

Overloaded Constructors
• It’s convenient to be able to give variables
of type Distance a value when they are first
created. That is, we would like to use
definitions like Distance width(5, 6.25);

• To do this we write a constructor like this:
Distance(int ft, float in) : feet(ft), inches(in)
{}

10

• This sets the member data feet and inches to
whatever values are passed as arguments to
the constructor.

• However, we also want to define variables
of type Distance without initializing them,
Distance dist1, dist2;
11

• An implicit no–argument constructor is built into
the program automatically by the compiler, and
it’s this constructor that created the objects, even
though we didn’t define it in the class.

• No–argument constructor is called the default
constructor. If it weren’t created automatically by
the constructor, you wouldn’t be able to create
objects of a class for which no constructor was
defined.
12

• To initialize data members in the default
(no–argument) constructor
Distance() : feet(0), inches(0.0)
{}

• Now we can use objects initialized with the
no–argument constructor and be confident
they represent no distance (0 feet plus 0.0
inches) rather than some arbitrary value.
13

• There are two explicit constructors with the
same name, Distance(), we say the
constructor is overloaded.

• Which of the two constructors is executed
when an object is created depends on how
many arguments are used in the definition:

14

• Distance length; // calls first constructor
• Distance width(11, 6.0); // calls second
constructor

15

Member Functions Defined Outside
the Class
• Last example shows a member function,
add_dist(), that is not defined within the
Distance class declaration.

• It is only declared inside the class, with the
statement
void add_dist( Distance, Distance );
16

the Class
• This tells the compiler that this function is a
member of the class but that it will be defined
outside the class declaration, someplace else in the
listing.

• The function name, add_dist(), is preceded by the
class name, Distance, and a new symbol—the
double colon (::). This symbol is called the scope
resolution operator.
17

the Class

18

Objects As Arguments
• The distances dist1 and dist3 are created using the
default constructor (the one that takes no
arguments).

• The distance dist2 is created with the constructor
that takes two arguments, and is initialized to the
values passed in these arguments.

• A value is obtained for dist1 by calling the
member function getdist(), which obtains values
from the user.Spring 2011, Engr. Anwar, Foundation University (FUIEMS), Rawalpindi
OOP 19

• To add dist1 and dist2 to obtain dist3. The function call in
main(),

• The object name is supplied as the argument.

• Since add_dist() is a member function of the Distance
class, it can access the private data in any object of class
Distance supplied to it as an argument, using names like
dist1.inches and dist2.feet.

20

• A member function is always given access
to the object for which it was called: the
object connected to it with the dot operator.

• But it may be able to access other objects.

21

• Besides dist3, the object for which it was
called, it can also access dist1 and dist2,
because they are supplied as arguments.

• Notice that the result is not returned by the
function. The return type of add_dist() is
void. The result is stored automatically in
the dist3 object.

22


23

• Every call to a member function is associated with a
particular object (unless it’s a static function).

• The function has direct access using the member names
alone (feet and inches) to all the members, whether private
or public, of that object.

• It also has indirect access, using the object name and the
member name, connected with the dot operator
(dist1.inches or dist2.feet) to other objects of the same
class that are passed as arguments.
24

Default Copy Constructor
• So far, we have seen two ways to initialize objects.

• A no–argument constructor can initialize data
members to constant values.

• A multi–argument constructor can initialize data
members to values passed as arguments.

25

• Another way to initialize an object: you can
initialize it with another object of the same type.

• You don’t need to create a special constructor for
this; one is already built into all classes.

• It’s called the default copy constructor. It’s a one–
argument constructor whose argument is an object
of the same class as the constructor.
26

Example
class Distance
{
private:
int feet;
float inches;
public: //Note: no one–arg constructor
Distance() : feet(0), inches(0.0)
{}

Distance(int ft, float in) : feet(ft), inches(in)
{}

void getdist() //get length from user
{
cout << “nEnter feet: ”; cin >> feet;
cout << “Enter inches: ”; cin >> inches;
}
void showdist() //display distance
{ cout << feet << “’–” << inches << ‘”’; }
}; OOP Spring 2011, Engr. Anwar, Foundation University (FUIEMS), Rawalpindi
27

Example
int main()
{
Distance dist1(11, 6.25); //two–arg constructor
Distance dist2(dist1); //one–arg constructor
Distance dist3 = dist1; //also one–arg constructor

cout << endl;

return 0;
}
28

• We initialize dist1 to the value of 11, 6.25 using the two–
argument constructor. Then we define two more objects of
type Distance, dist2 and dist3, initializing both to the value
of dist1.

• You might think this would require us to define a one–
argument constructor, but initializing an object with
another object of the same type is a special case. These
definitions both use the default copy constructor. The
object dist2 is initialized in the statement
Distance dist2(dist1);

29

• Default copy constructor for the Distance class to perform
a member–by–member copy of dist1 into dist2.

• A different format has exactly the same effect, causing
dist1 to be copied member–by–member into dist3:
Distance dist3 = dist1;

• Although this looks like an assignment statement, it is not.
Both formats invoke the default copy constructor, and can
be used interchangeably.

30

Returning Objects from Functions

Distance Distance::add_dist(Distance d2) int main()
{ {
Distance temp; Distance dist1, dist3;
temp.inches = inches + d2.inches; Distance dist2(11, 6.25);
dist1.getdist();
dist3 = dist1.add_dist(dist2);
if(temp.inches >= 12.0)
{
temp.inches –= 12.0; cout << “ndist2 = ”; dist2.showdist();
temp.feet = 1; cout << “ndist3 = ”; dist3.showdist();
} cout << endl;
temp.feet += feet + d2.feet;
return temp; return 0;
} }

31

• In previous example, two distances were passed to
add_dist() as arguments, and the result was stored
in the object of which add_dist() was a member,
namely dist3.

• In this example one distance, dist2, is passed to
add_dist() as an argument. It is added to the
object, dist1, of which add_dist() is a member, and
the result is returned from the function.
32

• In main() the result is assigned to dist3, in the
statement
dist3 = dist1.add_dist(dist2);

• There are some subtle differences. In the current
version, a temporary object of class Distance is
created. This object holds the sum until it can be
returned to the calling program. The sum is
calculated by adding two distances.

33

• The sum is calculated by adding two distances. The first is
the object of which add_dist() is a member, dist1. Its
member data is accessed in the function as feet and inches.

• The second is the object passed as an argument, dist2. Its
member data is accessed as d2.feet and d2.inches. The
result is stored in temp and accessed as temp.feet and
temp.inches.

• Dist1 is not modified; it simply supplies data to add_dist().

34


35

Structures and Classes
• Structures can be used in almost exactly the
same way that you use classes.

• The only formal difference between class
and struct is that in a class the members are
private by default, while in a structure they
are public by default.

36

• Format for classes: • Private is the default in
classes, this keyword is
class foo unnecessary.
{
private: •You can just as well write
class foo
int data1;
{
public: int data1;
void func(); public:
}; void func();
};
37

• To use a structure to accomplish the same thing
struct foo
{
void func();
private:
int data1;
};

– In most situations we don’t use a struct this way.
– We use structures to group only data, and classes to
group both data and functions.

38

Classes, Objects, and Memory
• Since now we know that each object created
from a class contains separate copies of that
class’s data and member functions.

• This is a good first approximation, since it
emphasizes that objects are complete, self–
contained entities, designed using the class
declaration.

39

• It’s true that each object has its own separate data items.
On the other hand, contrary to what you may have been led
to believe, all the objects in a given class use the same
member functions.

• The member functions are created and placed in memory
only once—when they are defined in the class declaration.
This makes sense; there’s really no point in duplicating all
the member functions in a class every time you create
another object of that class, since the functions for each
object are identical.

40


41

• In most situations you don’t need to know that
there is only one member function for an entire
class.

• It’s simpler to visualize each object as containing
both its own data and its own member functions.

• But in some situations, such as in estimating the
size of an executing program, it’s helpful to know
what’s happening behind the scenes.

42

Static Class Data
• Each object contains its own separate data,
we must now amend that slightly.

• If a data item in a class is declared as static,
then only one such item is created for the
entire class, no matter how many objects
there are.

43

Static Class Data
• A member variable defined as static is visible only
within the class, but its lifetime is the entire
program.

• It continues to exist even if there are no items of
the class.

• static class member data is used to share
information among the objects of a class.
44

Uses of Static Class Data
class X
{
public:
static int i;
};
int X::i = 0; // definition outside class declaration

45

• Classes can contain static member data and
member functions.

• When a data member is declared as static,
only one copy of the data is maintained for
all objects of the class.

46

class foo
{
private:
static int count; //only one data item for all objects
//note: *declaration* only!
public:
foo() //increments count when object created
{ count++; }
int getcount() //returns count
{ return count; }
};
int foo::count = 0; //*definition* of count

int main()
{
foo f1, f2, f3; //create three objects
cout << “count is ” << f1.getcount() << endl; //each object
cout << “count is ” << f2.getcount() << endl; //sees the
cout << “count is ” << f3.getcount() << endl; //same value
return 0;
} OOP Spring 2011, Engr. Anwar, Foundation University (FUIEMS), Rawalpindi
47

• The class foo in this example has one data item,
count, which is type static int. The constructor for
this class causes count to be incremented.

• In main() we define three objects of class foo.
Since the constructor is called three times, count is
incremented three times.

• Another member function, getcount(), returns the
value in count.

48


• Static class variables are not used as often as ordinary non–
static variables, but they are important in many situations.
49


50

• Static member data requires an unusual format.
Ordinary variables are declared (the compiler is
told about their name and type) and defined (the
compiler sets aside memory to hold the variable)
in the same statement.

• Static member data, on the other hand, requires
two separate statements. The variable’s
declaration appears in the class declaration, but the
variable is actually defined outside the class, in
much the same way as an external variable.
51

• Putting the definition of static member data
outside of the class also serves to emphasize that
the memory space for such data is allocated only
once, before the program starts to execute.

• One static member variable is accessed by an
entire class; each object does not have its own
version of the variable, as it would with ordinary
member data. In this way a static member variable
is more like a global variable.
52

• It’s easy to handle static data incorrectly, and the
compiler is not helpful about such errors.

• If you include the declaration of a static variable
but forget its definition, there will be no warning
from the compiler.

• Everything looks fine until you get to the linker.

53

const and Classes
• const used on normal variables to prevent
them from being modified.

• A const member function guarantees that it
will never modify any of its class’s member
data.

54

Example: const and Classes

The non–const function nonFunc() can modify member data alpha,
but the constant function conFunc() can’t.
If it tries to, a compiler error results.
55

const and Classes
• Member functions that do nothing but acquire data
from an object are obvious candidates for being
made const, because they don’t need to modify
any data.

• Making a function const helps the compiler flag
errors, and tells anyone looking at the listing that
you intended the function not to modify anything
in its object.
56


57


58

const
• A compiler error is generated if you attempt
to modify any of the data in the object for
which this constant function was called.

59

const Objects

60

const Objects
• Non–const functions, such as getdist(),
which gives the object a new value obtained
from the user, are illegal. In this way the
compiler enforces the const value of
football.

• Make const any function that does not
modify any of the data in its object.

61

Summary
• A class is a specification or blueprint for a number
of objects. Objects consist of both data and
functions that operate on that data.

• In a class declaration, the members—whether data
or functions—can be private, meaning they can be
accessed only by member functions of that class,
or public, meaning they can be accessed by any
function in the program.
62

Summary
• A member function is a function that is a member of a
class. Member functions have access to an object’s private
data, while non–member functions do not.

• A constructor is a member function, with the same name
as its class, that is executed every time an object of the
class is created.

• A constructor has no return type but can take arguments. It
is often used to give initial values to object data members.
Constructors can be overloaded, so an object can be
initialized in different ways.

63

Summary
• A destructor is a member function with the same
name as its class but preceded by a tilde (~). It is
called when an object is destroyed. A destructor
takes no arguments and has no return value.

• In the computer’s memory there is a separate copy
of the data members for each object that is created
from a class, but there is only one copy of a class’s
member functions. A data item can be restricted to
a single instance for all objects of a class by
making it static.
64

Summary
• One benefit of OOP that you may have glimpsed
already is the close correspondence between the
real–world things being modeled by the program
and the C++ objects in the program.

• In a procedural program, by contrast, the external
variables and functions connected with a real–
world object are distributed all over the listing;
they don’t form a single, easily grasped unit.
65

Summary
• In some situations it may not be obvious what parts of a
real–life situation should be made into objects. If you’re
writing a program that plays chess, for instance, what are
the objects? The chessmen, the squares on the board, or
possibly entire board positions?

• In small programs, such as many of those in this book, you
can often proceed by trial and error. You break a problem
into objects in one way and write trial class declarations
for these objects. If the classes seem to match reality in a
useful way, you continue. If they don’t, you may need to
start over, selecting different entities to be classes. The
more experience you have with OOP, the easier it will be
to break a programming problem into classes.
66

Summary
• OOP was devised to cope with the complexity of
large programs. Smaller programs, such as the
examples in this chapter, have less need for the
organizational power that OOP provides. The
larger the program, the greater the benefit.

• In an OO program the compiler can find many
more conceptual errors than in a procedural
program.
67

oop Lecture 11

More Related Content

What's hot (20)

Similar to oop Lecture 11 (20)

Recently uploaded (20)

oop Lecture 11