ObjectivesIn this chapter you will learn:About default constructorsHow to create parameterized constructorsHow to work with initialization listsHow to create copy constructors
1
Advanced ConstructorsConstructors can do more than
initialize data members
They can execute member functions and perform other types of initialization routines that a class may require when it first starts
2
Default ConstructorsThe default constructor does not include
parameters, and is called for any declared objects of its class to which you do not pass arguments
Remember that you define and declare constructor functions the same way you define other functions, although you do not include a return type because constructor functions do not return values
3
Constructor Function
4
A Constructor is a special member function whose task is to initialize the object of its class. It is special because it name is same as class name.The Constructor is invoked whenever an object of its associated class is created. It is called constructor because it constructs the values of data members of the class.
Default ConstructorsThe constructor function in Figure is an
example of a default constructorIn addition to initializing data members
and executing member functions, default constructors perform various types of behind-the-scenes class maintenance
5
Simple Program
6
// default constructor#include<iostream>Using namespace std;Class integer{Int m,n;Public: Integer(void); // constructor declared Void getinfo( );};Integer :: integer void( ) // constructor defined
{m= 0;n=0;}
Parameterized ConstructorsThe constructor integer( ) define above
initialize the data members of all the objects to zero. However is practice it may be necessary to initialize the various data elements of different objects with different values, when they are created.
A parameterized constructor allows a client to pass initialization values to your class during object instantiation
Instead of assigning default values, you can allow a client to pass in the value for these data members by designing the constructor function with parameters.
7
8
Class integer {Int m, n;Public : Integer (int x, int y);};Integer :: integer(int x,int y){m= x;n=y;}
By Calling the Constructor explicitly By Calling the consructor implicitly
integer int1 = integer(0,100);Explicitly called
Integer int1(0,100)Implicitly called.
Shorthand method.
9
Copy ConstructorThere will be times when you want to
instantiate a new object based on an existing object
C++ uses a copy constructor to exactly copy each of the first object’s data members into the second object’s data members in an operation known as member wise copying
A copy constructor is a special constructor that is called when a new object is instantiated from an old object
10
Copy ConstructorThe syntax for a copy constructor declaration is
class_name :: class_name (class_name &ptr)The Copy Constructor may be used in the following
format also using a const keyword. class_name :: class_name (const class_name &
ptr)Copy Constructor are always used when the compiler
has to create a temporary object of a class object.The copy constructor are used in the following situations:-
The Initialization of an object by another object of the same class.
Return of object as a function value.Stating the object as by value parameters of a
function.
11
Copy Constructor Example with Program
//fibonacci series using copy constructor
#include<iostream>
Using namespaces std ;Class fibonacci {Private : Unsigned long int f0,f1,fib;Public :Fiboancci () // constructor {F0=0;F1=1;Fib=f0+f1;}Fibonacci (fibonacci &ptr) // copy construtor{F0=ptr.f0;F1=ptr.f1;Fib=prt.fib;}
12
Void increment ( ){F0=f1;F1=fib;Fib=f0+f1;}Void display ( ){Cout<<fib<<‘/t’;}};Void main( ){Fibonacci number ;For(int i=0;i<=15;++i){Number.display();Number.increment();}}
#include<iostream> void display (void)Using namespace std ; { cout<<id;Class code // class name }{ };Int id; int main()Public : {Code() code A(100);//object A is created// constructor name same as class name code B(A); // copy const.
called{ code C= A; // CC called again} code D; // D is created, not
intilizedCode(int a ) { // constructor again D=A; // C C not called Id=a; cout<<“\n” id of A:=A.display();} cout<<“\n” id of B:=B.display();Code (code &x) // copy constuctor cout<<“\n” id of C:=C.display();{ id=x.id; // copy in the value cout<<“\n” id of
D:=D.display();} return 0;
} 13
DestructorsJust as a default constructor is called when a
class object is first instantiated, a default destructor is called when the object is destroyed
A default destructor cleans up any resources allocated to an object once the object is destroyed
The default destructor is sufficient for most classes, except when you have allocated memory on the heap
14
DestructorsYou create a destructor function using the
name of the class, the same as a constructor
A destructor is commonly called in two ways:
When a stack object loses scope because the function in which it is declared ends
When a heap object is destroyed with the delete operator
15
Syntax rules for writing a dectructor function :A destructor function name is the same as
that of the class it belongs except that the first character of the name must be a tilde ( ~).
It is declared with no return types ( not even void) since it cannot even return a value.
It cannot de declared static ,const or volatile.It takes no arguments and therefore cannot
be overloaded.It should have public access in the class
declaration.
16
Class employee { Private :Char name[20];Int ecode ;Char address[30];Public :Employee ( ); // constructor ~ Employee ( ); // destructorVoid getdata( );Void display( );};
17
18
#include<iostream>#include<stdio>Class account {Private : Float balance;Float rate;Public: Account( ); // constructor name~ account ( );// destructor nameVoid deposit( );Void withdraw( );Void compound( );Void getbalance( );Void menu( );}; //end of class definition Account :: account( ) // constructor{Cout<<“enter the initial balance\n”;Cin>>balance;}Account :: ~account( ) // destructor
19
{Cout<<“data base has been deleted\n”}// to deposit Void account ::deposit( ){Float amount;Cout<<“how much amount want to deposit”;Cin>>amount;Balance=balace+amount ;}
// the program is not complete , the purpose is to clear the function of constructor and destructor
#include<iostream>Using namespace std;Int count =0;Class alpha{Public : Alpha(){Count ++;Cout <<“\n No. of object created “<<count;}~alpha(){
20
Cout<<“\n No. of object destroyed “<<count;Count --;}};Int main(){ cout<<“\n \n Enter main\n”;Alpha A1 A2 A3 A4;{Cout<<“\n\n Enter block 1\n”;Alpha A5;}{ cout<<“\n\n Enter Block 2 \n”;Alpha A6;}
21
Cout<<“\n \n RE-enter Main\n”;Return 0; Enter Block 2
No. of object created :5} Re-Enter Main
No. of object destroyed Output : Enter Main 4,3,2,1No. of object created 1No. of object created 2No. of object created 3No. of object created 4Enter Block 1No. ofobject created 5No. of object Destroyed 5
22
Static Class MembersYou can use the static keyword when
declaring class membersStatic class members are somewhat different
from static variablesWhen you declare a class member to be static, only one copy of that class member is created during a program’s execution, regardless of how many objects of the class you instantiate
Figure 7-38 illustrates the concept of the static and non-static data members with the Payroll class
23
Multiple Class Objects with Static and Non-Static Data Members
24
Static Data MembersYou declare a static data member in your
implementation file using the syntax static typename;, similar to the way you define a static variable
static data members are bound by access specifiers, the same as non-static data members
This means that public static data members are accessible by anyone, whereas private static data members are available only to other functions in the class or to friend functions
25
Static Data MembersYou could use a statement in the class
constructor, although doing so will reset a static variable’s value to its initial value each time a new object of the class is instantiated
Instead, to assign an initial value to a static data member, you add a global statement to the implementation file using the syntax type class::variable=value;
Initializing a static data member at the global level ensures that it is only initialized when a program first executes—not each time you instantiate a new object
26
Static Data MembersFigure 7-39 contains an example of the Stocks class, with the iStockCount static data member
Statements in the constructor and destructor increment and decrement the iStockCount variable each time a new Stocks object is created or destroyed
Figure 7-40 shows the program’s output
27
Static Data MembersYou can refer to a static data member by appending
its name and the member selection operator to any instantiated object of the same class, using syntax such as stockPick.iStockCount
By using the class name and the scope resolution operator instead of any instantiated object of the class, you clearly identify the data member as static
Figure 7-41 in the text shows an example of the Stocks class program with the dPortfolioValue static data member
The dPortfolioValue static data member is assigned an initial value of 0 (zero) in the implementation file
28
Static Data Members
To add to the Estimator class a static data member that stores the combined total of each customer’s estimate, follow the instructions listed on pages 403 and 404 of the textbook
29
Static Member FunctionsStatic member functions are useful for
accessing static data membersLike static data members, they can be
accessed independently of any individual class objects
This is useful when you need to retrieve the contents of a static data member that is declared as private
Static member functions are somewhat limited because they can only access other static class members or functions and variables located outside of the class
30
Static Member FunctionsYou declare a static member function similar
to the way you declare a static data member-- by preceding the function declaration in the interface file with the static keyword
You do not include the static keyword in the function definition in the implementation file
Like static data members, you need to call a static member function’s name only from inside another member function of the same class
31
Static Member FunctionsYou can execute static member functions
even if no object of a class is instantiatedOne use of static member functions is to
access private static data membersTo add to the Estimator class a static
member function that returns the value of the static lCombinedCost data member, use the steps on pages 405 and 406 of the textbook
32
Constant ObjectsIf you have any type of variable in a
program that does not change, you should always use the const keyword to declare the variable as a constant
Constants are an important aspect of good programming technique because they prevent clients (or you) from modifying data that should not change
Because objects are also variables, they too can be declared as constants
33
Constant ObjectsAs with other types of data, you only declare
an object as constant if it does not changeConstant data members in a class cannot be
assigned values using a standard assignment statement within the body of a member function
You must use an initialization list to assign initial values to these types of data members
There is an example of this code shown on page 407 of the textbook
34
Constant ObjectsAnother good programming technique is to
always use the const keyword to declare get functions that do not modify data members as constant functions
The const keyword makes your programs more reliable by ensuring that functions that are not supposed to modify data cannot modify data
To define the Estimator class’s get functions as constant, perform the procedures listed on page 408 of the textbook
35
SummaryThe default constructor is the constructor
that does not include any parameters and that is called for any declared objects of its class to which you do not pass arguments
Initialization lists, or member initialization lists, are another way of assigning initial values to a class’s data members
A copy constructor is a special constructor that is called when a new object is instantiated from an old object
36
SummaryOperator overloading refers to the creation of
multiple versions of C++ operators that perform special tasks required by the class in which an overloaded operator function is defined
When you declare a class member to be static, only one copy of that class member is created during a program’s execution, regardless of how many objects of the class you instantiate
37