CSC-210: Object Oriented Programming

Static and Const

Lecture 05

By: Ms. Zupash Awais

Bahria University Lahore Campus
  A static data member is useful, when all objects of
the same class must share a common
information.
 Just write static keyword prefix to regular variable
Static Data  It is initialized to zero when first object of class
Members created
 Only one copy is created for each object
 Its lifetime is entire program
  Data members of the class which are shared by all objects
are known as static data members.
 Only one copy of a static variable is maintained by the
class, and it is common for all objects.
 Static members are declared inside the class and
defined outside the class.

Static Data  It is initialized to zero when the first object of its class is
created.
Member  you cannot initialize a static member variable inside the
class declaration.
 It is visible only within the class, but its lifetime is the entire
program.
 Static members are generally used to maintain values
common to the entire class.
class demo Static Data members
{
static int count;
public:
void getcount()
{ count
cout<<"count="<<++count;
} 0
3
2
1
};

int demo::count;
d1 d2 d3
int main()
{
demo d1,d2,d3;
d1.getcount(); Static members are declared inside
d2.getcount(); the class and defined outside the
d3.getcount(); class.
return 0;
}
class demo
Regular Data members
{
int count;

public:
void getcount()
{
count = 0; d1 d3
cout<<"count="<< ++count;
d2
}
};
int main() 10 01 10
{
demo d1,d2,d3; count count count
d1.getcount();
d2.getcount();
d3.getcount();
return 0;
}
  Static member functions can access only static members
of the class.
 Static member functions can be invoked using class
name, not object.

Static Member  There cannot be static and non-static version of the same
function.
Functions
 They cannot be virtual.
 They cannot be declared as constant or volatile.
 A static member function does not have this pointer.
class item C++ Code
{
int number;
static int count;// static variable declaration
public:
void setdata(int a){
number = a;
count++; int main()
} {
static void getcount(){ item a,b,c;
cout<<“value of number: ”<<number;
cout<<“\nvalue of count: ”<<count; a.setdata(100);
} item::getcount();
};
int item :: count=10; // static variable definition b.setdata(200);
Output: item::getcount();
value of count: 11 c.setdata(300);
value of count: 12 item::getcount();
value of count: 13 return 0;
}
 C++ Code
#include<iostream>
using namespace std;
class Count
{
static int counter;
public:
Count() Output:
{ 1
cout << counter++ <<endl; 2
} 3
};

int Count::counter = 1;

void main()
{
Count c, c1, c2;
}
class Life class Life
C++ Code
{ {
int i; int i;
public: public:
Life() Life()
{ {
i = 0; i = 0;
cout << "Constructor\n"; cout << "Constructor\n";
} }
~Life() ~Life()
{ {
cout << "Destructor\n"; cout << "Destructor\n";
} }
}; };

int main() int main()

{ {
int x = 0; int x = 0;
if (x == 0) if (x == 0)
{ {
Life obj; static Life obj;
} }
cout << "End of main\n"; cout << "End of main\n";
} }
  The const member functions are the functions which are
declared as constant in the program.
 The object called by these functions cannot be modified.
 It is recommended to use const keyword so that accidental
changes to object are avoided.

Const Members  Const data members must be initialized by the

constructor using an initialization list.
 Once initialized, a const data member may never be
modified, not even in the constructor or destructor.

 In Java you make constant variable using static final

keyword
 class Constant
{
const int i = 10;
public:
Constant() :i(1) {}
void display()
{

Example C++ }
cout << i;

};
int main()
{
Constant c;
c.display();
}
  You can declare a method of a class to be const
 A const method can be called by any type of object.
 Non-const functions can be called by non-const objects
only.

Const Methods  A const method can be overloaded with a non-

const version.
 Constructors and destructors can never be declared
as const. They are always allowed to modify an object
even if the object is const.
 #include<iostream>
using namespace std;
class Constant
{
const int i = 10;
int j;
public:
Constant() :i(1),j(0) {}
void display() const
{
Example cout << i<<“ “<<j<<endl;
}
};

int main()
{
Constant c,c1(40);
c.display();
c1.display();
}
  The objects of a class can also be declared as const.
 An object declared as const cannot be modified and
hence, can invoke only const member functions as
these functions ensure not to modify the object.
Const Objects  A const object can be created by prefixing the const
keyword to the object declaration. Any attempt to
change the data member of const objects results in a
compile-time error.
#include<iostream>
using namespace std;
class Constant
{
const int i = 10;
int j;
public:
Constant() :i(1),j(0) {}
Constant(int a) :j(a) {}
void display() const
{
cout << i << " " << j << endl;
}
void display2() int main()
{ {
cout << i << " " << j << endl; Constant c,c1(40);
} c.display();
}; c1.display();
const Constant c2(2),c3;
c2.display();
c3.display();
}
  A copy constructor is a member function that initializes
an object using another object of the same class. A copy
constructor has the following general function
Copy prototype:
Constructor ClassName (const ClassName &old_obj);
#include<iostream> C++ Code
using namespace std;
class Real
{
int i,j;
public:
Real() :i(0), j(0) { cout << "Default Constructor Called\n"; }
Real(int a, int b)
{
i = a;
j = b;
cout << "\nParameterized Constructor Called\n";
}
Real(const Real& r)
{ int main()
i = r.i; {
j = r.j; Real r1;
cout << "\nCopy Constructor Called\n"; r1.display();
} Real r2(2, 4);
void display() r2.display();
{ Real r3 = r2;
cout << i << " " << j << endl; r3.display();
}
}
};