Oop04 6

Object Oriented Programming License: http://creativecommons.org/licenses/by-nc-nd/3.0/ Object Oriented Programming

Default Constructor:
Initializing Class Objects: CONSTRUCTORS A constructor that defaults all its arguments or requires no arguments, i.e.
a constructor that can be invoked with no arguments.
The class designer can guarantee initialization of every object by providing a
special member function called the constructor. class Point{ // Declaration Point Class
int x,y; // Attributes: x and y coordinates
The constructor is invoked automatically each time an object of that class is public:
created (instantiated). Point(); // Declaration of the default constructor
These functions are used to (for example) assign initial values to the data bool move(int, int); // A function to move points
members, open files, establish connection to a remote computer etc. void print(); // to print coordinates on the screen
};
The constructor can take parameters as needed, but it cannot have a return
// Default Constructor
value (even not void).
Point::Point()
The constructor has the same name as the class itself. {
x = 0; // Assigns zero to coordinates
Constructors must be public members of a class.
y = 0;
There are different types of constructors. }
// -------- Main Program -------------
For example, a constructor that defaults all its arguments or requires no int main()
arguments, i.e. a constructor that can be invoked with no arguments is called See Example e41.cpp
{
default constructor. Point p1, p2; // Default construct is called 2 times
In this section we will discuss different kinds of constructors. Point *ptr; // ptr is not an object, constructor is NOT called
ptr = new Point; // Object is created, default constructor is called
http://www.faculty.itu.edu.tr/buzluca ©1999-2010 Dr. Feza BUZLUCA 4.1 http://www.faculty.itu.edu.tr/buzluca ©1999-2010 Dr. Feza BUZLUCA 4.2
http://www.buzluca.info http://www.buzluca.info

Object Oriented Programming Object Oriented Programming

// A constructor with Parameters
Constructors with Parameters:
// Points may not have negative cooridnates
Like other member functions, constructors may also have parameters. Point::Point(int x_first, int y_first)
Users of the class (client programmer) must supply constructors with {
necessary arguments. if ( x_first < 0 ) // If the given value is negative
x = 0; // Assigns zero to x
class Point{ // Declaration Point Class else
int x,y; // Properties: x and y coordinates x = x_first;
public: if ( y_first < 0 ) // If the given value is negative
Point(int, int); // Declaration of the constructor y = 0; // Assigns zero to y
bool move(int, int); // A function to move points else
void print(); // to print coordinates on the screen y = y_first;
}; }

// -------- Main Program -------------
This declaration shows that the users of the Point class have to give two integer int main()
arguments while defining objects of that class. {
Point p1(20, 100), p2(-10, 45); // Construct is called 2 times
Example: Point *ptr = new Point(10, 50); // Construct is called once
In the following example, it is assumed that the points are not allowed to have Point p3; // ERROR! There is not a default constructor
negative coordinates. :
} See Example e42.cpp



Default Values of Constructor Parameters Multiple Constructors
Like other functions, parameters of constructors may also have default values. The rules of function overloading is also valid for constructors. So, a class
class Point{ may have more than one constructor with different type of input parameters.
public:
Point (int = 0, int = 0); // Default values must be in the declaration Point::Point() // Default constructor
: {
}; ............... // Body is not important
Point::Point (int x_first, int y_first) }
{
if ( x_first < 0 ) // If the given value is negative Point::Point(int x_first, int y_first) // A constructor with parameters
x = 0; // Assigns zero to x {
else x = x_first; ................. // Body is not important
if ( y_first < 0 ) // If the given value is negative }
y = 0; // Assigns zero to y
else y = y_first; Now, the client programmer can define objects in different ways:
}
Point p1; // Default constructor is called
Now, client of the class can create objects as follows: Point p2(30, 10); // Constructor with parameters is called
Point p1(15, 75); // x=15, y=75 The following statement causes an compiler error, because the class does not
Point p2(100); // x=100, y=0 include a constructor with only one parameter.
This function can be also used as a default constructor Point p3(10); //ERROR! There isn't a constructor with one parameter
Point p3; // x=0, y=0

1


Initializing Arrays of Objects
If the class has a default constructor the programmer may define an array of
When an array of objects is created, the default constructor of the class is
objects as follows:
invoked for each element (object) of the array one time.
Point array[5]= { (10) , (20) , (30,40) }; // An array with 5 elements
Point array[10]; // Default constructor is called 10 times
Here, an array with 5 elements has been defined, but the list of initial values
To invoke a constructor with arguments, a list of initial values should be used.
contains only 3 values, which are sent as arguments to the constructors of the
// Constructor ( can be called with zero, one ore two arguments) first three elements.
Point(int x_first = 0, int y_first = 0) { .... }
For the last two elements, the default constructor is called.
// Array of Points
Point array[]= { (10) , (20) , (30,40) }; // An array with 3 elements (objects) To call the default constructor for an object, which is not at the end of the
or to make the program more readable array:
Point array[]= { Point(10) , Point(20) , Point(30,40) }; // An array with 3 objects Point array[5]= { (10) , (20), Point() , (30,40) }; // An array with 5 elements
Three objects of type Point has been created and the constructor has been invoked Here, for objects array[2] and array[4] the default constructor is invoked.
three times with different arguments.
Objects: Arguments: Following statements cause compiler errors:
array[0] x_first = 10 , y_first = 0 Point array[5]= { (10) , (20) , , (30,40) }; // ERROR! Not readable
array[1] x_first = 20 , y_first = 0
array[2] x_first = 30 , y_first = 40 Point array[5]= { (10) , (20) , () , (30,40) }; // ERROR! Not readable



Constructor Initializers The solution is to use a constructor initializer.
Instead of assignment statements constructor initializers can be used to class C{
initialize data members of an object. const int CI; // constant data member
int x; // nonconstant data member
Specially, to assign initial value to a constant member using the constructor
public:
initializer is the only way.
C() : CI(0) // initial value of CI is zero
Consider the class: { x = -2; }
class C{ };
const int CI; // constant data member
int x; // nonconstant data member All data members of a class can be initialized by using constructor initializers.
public: class C{
C( ) { // Constructor const int CI; // constant data member
x = 0; // OK x not const int x; // nonconstant data member
// CI = 0; // ERROR! CI is const public:
} C(int, int);
}; };
The example below is not correct, either: C::C( int a, int b ) : CI(a), x(b) // Definition of the Construtor
class C{ {} // The body may be empty
//const int CI = 10 ; // ERROR! int main() {
int x; // nonconstant data member C obj1(-5, 1); // Objects may have different const values
}; C obj2(0, 18);


DESTRUCTORS // Constructor : copies the input character array that terminates with a null character
• The destructor is called automatically // to the contents of the string
1. when each of the objects goes out of scope or
2. a dynamic object is deleted from memory by using the delete operator. String::String(const char *in_data)
{
• A destructor is characterized as having the same name as the class but with a size = strlen(in_data); // strlen is a function of the cstring library
tilde ‘~’ preceded to the class name. contents = new char[size +1]; // +1 for null ( '0' ) character
• A destructor has no return type and receives no parameters. strcpy(contents, in_data); // input_data is copied to the contents
• A class may have only one destructor. }

Example: A String class size void String::print() int main()
*contents t e x t 0 { {
class String{ String string1("string 1");
cout << contents << " " << size << endl;
int size; // Length (number of chars) of the string String string2("string 2");
}
char *contents; // Contents of the string string1.print();
public: // Destructor string2.print();
String(const char *); // Constructor // Memory pointed by contents is given back return 0; // destructor is called twice
void print(); // An ordinary member function String::~String() }
~String(); // Destructor {
}; delete[] contents;
}
Actually, the standard library of C++ contains a string class. Programmers don't See Example e43.cpp
need to write their own String class. We write this class only to show some concepts.

2


Copy Constructor
• Sometimes we want to create a new object, which is the copy (has the same data)
of an existing object. The copy constructor, generated by the compiler can not copy the memory locations
• Copy constructor is a special type of constructors and used to copy the contents pointed by the member pointers.
of an object to a new object during construction of that new object. The programmer must write its own copy constructor to perform these operations.
•The type of its input parameter is a reference to objects of the same type. The
input argument is the object that will be copied into the new object.
Example: User-written copy constructor
•The copy constructor is generated automatically by the compiler if the class
author fails to define one. The new object
Existing (original) object:
• If the compiler generates it, it will simply copy the contents of the original into
the new object as a byte by byte copy. size: 8 8 size
• For simple classes with no pointers, that is usually sufficient, but if there is a contents: 0x008d0080 0x00ef0080 contents
pointer as a class member so a byte by byte copy would copy the pointer from one s s
to the other and they would both be pointing to the same allocated member. t t
• For example the copy constructor, generated by the compiler for the String class r r
will do the following job: i i
size: 8 8 size n n
contents g g
contents: 0x008d0080 0x008d0080
Existing object The new object 1 1
0 0
s t r i n g 1 0


Example: The copy constructor of the String class Constant Objects and Const Member Functions
class String{
The programmer may use the keyword const to specify that an object is
int size;
char *contents; not modifiable.
public: Any attempt to modify (to change the attributes) directly or indirectly (by
String(const char *); // Constructor calling a function) causes a compiler error.
String(const String &); // Copy Constructor
void print(); // Prints the string on the screen For example:
~String(); // Destructor const ComplexT CZ(0,1); // Constant object
};
C++ compilers totally disallow any member function calls for const objects.
String::String(const String &object_in) // Copy Constructor
{ The programmer may declare some functions as const, which do not modify
cout<< "Copy Constructor has been invoked" << endl; any data (attributes) of the object.
size = object_in.size; Only const functions can operate on const objects.
contents = new char[size + 1]; // +1 for null character
strcpy(contents, object_in.contents); Example:
} class Point{ // Declaration Point Class
int x, y; // Attributes: x and y coordinates
int main()
public:
{ See Example e44.cpp
String my_string("string 1"); Point(int, int); // Declaration of the constructor
my_string.print(); bool move(int, int); // A function to move points
String other = my_string; // Copy constructor is invoked void print() const; // constant function: prints coordinates on the screen
String more(my_string); // Copy constructor is invoked };


// Constant function: It prints the coordinates on the screen Static Class Members
void Point::print() const Normally, each object of a class has its own copy of all data members of the class.
{ In certain cases only one copy of a particular data member should be shared by all
cout << "X= " << x << ", Y= " << y << endl; objects of a class. A static data member is used for this reason.
} class A{
Object p Object q
// -------- Main Program ------------- char c;
int main() static int i; static
}; char c char c
{ int i
const Point cp(10,20); // constant point
int main()
Point ncp(0,50); // non-constant point
{ char c
cp.print(); // OK. Const function operates on const object
A p, q, r;
cp.move(30,15); // ERROR! Non-const function on const object
: Object r
ncp.move(100,45); // OK. ncp is non-const
}
return 0;
} Static data members exist even no objects of that class exist.
Static data members can be public or private.
A const method can invoke only other const methods, because a const method is not
To access public static data when no objects exist use the class name and binary
allowed to alter an object's state either directly or indirectly, that is, by invoking
scope resolution operator. For example A::i= 5;
some nonconst method. See Example e45.cpp To access private static data when no objects exist, a public static member
Declare necessary methods as constant to prevent errors and function must be provided.
See Example e46.cpp
to allow users of the class to define constant objects. They must be initialized once (and only once) at file scope.

3


Passing Objects to Functions as Arguments Avoiding Temporary Objects
Objects should be passed or returned by reference unless there are compelling In the previous example, within the add function a temporary object is defined
reasons to pass or return them by value. to add two complex numbers.
Passing or returning by value can be especially inefficient in the case of objects. Because of this object, constructor and destructor are called.
Recall that the object passed or returned by value must be copied into stack and
Avoiding the creation of a temporary object within add() saves time and
the data may be large, which thus wastes storage. The copying itself takes time.
memory space.
If the class contains a copy constructor the compiler uses this function to copy
the object into stack. ComplexT ComplexT::add(const ComplexT& c)
See Example e47.cpp {
double re_new,im_new;
We should pass the argument by reference because we don’t want an unnecessary re_new = re + c.re;
copy of it to be created. Then, to prevent the function from accidentally im_new = im + c.im;
modifying the original object, we make the parameter a const reference. return ComplexT(re_new,im_new); // Constructor is called
See Example: e48.cpp }
ComplexT & ComplexT::add(const ComplexT& z)
{ The only object that’s created is the return value in stack, which is always
ComplexT result; // local object Remember, local variables can necessary when returning by value.
result.re = re + z.re; not be returned by reference. This could be a better approach, if creating and destroying individual member
result.im = im + z.im; data items is faster than creating and destroying a complete object.
return result; // ERROR!
See Example: e49.cpp
}


NESTING OBJECTS: Classes as Members of Other Classes Example: A class to define fractions
A class may include objects of other classes as its data members. class Fraction{ // A class to define fractions
In the example below, a class is designed (ComplexFraction) to define complex int numerator, denominator;
numbers. The data members of this class are fractions which are objects of public:
another class (Fraction). Fraction(int, int); // CONSTRUCTOR
Fraction ComplexFraction
void print() const;
ComplexFraction: numerator re };
a c numerator
z= + i denominator
b d denominator
Fraction::Fraction(int num, int denom) // CONSTRUCTOR
re:Fraction im:Fraction constructor {
print() numerator = num;
im
The relation between Fraction and ComplexFraction is numerator if (denom==0) denominator = 1;
called "has a relation". Here, ComplexFraction has a denominator else denominator = denom;
Fraction (actually two Fractions). cout << "Constructor of Fraction" << endl;
}
Here, the author of the class ComplexFraction has to
supply the constructors of its object members (re , constructor void Fraction::print() const
im) with necessary arguments. print() {
Member objects are constructed in the order in cout << numerator << "/" << denominator << endl;
which they are declared and before their enclosing }
class objects are constructed.


Example: A class to define complex numbers. It contains two objects as members Dynamic Memebers (Pointers as members)
class ComplexFraction{ // Complex numbers, real and imag. parts are fractions
Fraction re, im; // objects as data members of another class Instead of static objects, data members of a class may also be pointers to
public: objects.
ComplexFraction(int,int); // Constructor class ComplexFraction{ // Complex numbers, real and imag. parts are fractions
void print() const; Fraction *re, *im; // pointers to objects as data members of another class
}; public:
ComplexFraction::ComplexFraction(int re_in, int im_in) : re(re_in, 1) , im(im_in, 1) :
{ };
:
} Now, only the pointers (addresses) of member objects are included in objects of
Data members are initialized ComplexFraction. The member objects re and im must be created seperatley.
void ComplexFraction::print() const
{ ComplexFraction
re.print(); // print of Fraction is called
im.print(); // print of Fraction is called When an object goes out of scope, Fraction * re
} the destructors are called in numerator
reverse order: The enclosing object denominator re: Fraction
int main()
is destroyed first, then the
{
member (inner) object. Fraction * im
ComplexFraction cf(2,5);
cf.print(); numerator
im: Fraction
return 0; denominator
See Example: e410.cpp See Example: e411.cpp
}

4


In this case the enclosing object must either initialize member objects (memory Working with Multiple Files (Separate Compilation)
allocation) by itself or get the addresses of its members as paremeters. It is a good way to write each class or a collection of related classes in separate
If memory allocation is performed in the constructor then these locations shall be files. It provides managing the complexity of the software and reusability of
released in the destructor. classes in new projects.
class ComplexFraction{ // Complex numbers: has two fractions header header header Only declarations
Fraction *re, *im; // pointers to objects
public:
ComplexFraction(int,int); // Constructor
: C++ C++ Definitions
~ComplexFraction(); // Destructor source source
};
COMPILER
// Constructor
ComplexFraction::ComplexFraction(int re_in, int im_in)
{ library object object object
re= new Fraction(re_in,1); // Destructor
im= new Fraction(im_in,1); ComplexFraction::~ComplexFraction()
} { LINKER
delete re;
See Example: e412.cpp
delete im; executable
}

Object Oriented Programming

When using separate compilation you need some way to automatically compile each
file and to tell the linker to build all the pieces along with the appropriate
libraries and startup code into an executable file.
The solution, developed on Unix but available everywhere in some form, is a
program called make.
Compiler vendors have also created their own project building tools.
These tools ask you which files are in your project and determine all the
relationships themselves.
These tools use something similar to a makefile, generally called a project file,
but the programming environment maintains this file so you don’t have to worry
about it.
The configuration and use of project files varies from one development
environment to another, so you must find the appropriate documentation on how
to use them (although project file tools provided by compiler vendors are usually
so simple to use that you can learn them by playing around).
We will write the example e410.cpp about fractions and complex numbers again.
Now we will put the class for fractions and complex numbers in separate files.

See Example: e413.zip
http://www.faculty.itu.edu.tr/buzluca ©1999-2010 Dr. Feza BUZLUCA 4.27
http://www.buzluca.info

5

Oop04 6

More Related Content

What's hot (20)

Similar to Oop04 6 (20)

More from schwaa (7)

Oop04 6