Open Means Open Means

Class is a key feature in C++. It makes programming much easier. To implement the class we need to create objects for that class. So, let's start with 'what is a class and an object?'

Class: Class is basically a template of variables and member functions.
Object: An object is an instance of a class.

How to create a class

To create a class you need to use the 'class' keyword. After that you need to specify the name of the class. The body of the class should be enclosed with curly braces. At the end you have to add a semicolon. For example,

class Circle(){ 
  private: 
  int r; 
  public: 
  getdata(); 
  area();
};

This is a way you create a class. You can write the function in the class and also outside the class. In the above example only the name of the function is written. This means that the function needs to be written outside the class. If you wanted you can write the function there itself like:

class Circle(){
  private: 
  int r; 
  public: 
  getdata(){ 
    cout<<"Enter the radius: "<<endl; 
    cin>>r; 
    } 
  area(){ 
    float a; 
    a=3.14*r*r; 
    cout<<"The area is : "<<a<<endl; 
    }
}; 

If you want to write the function outside the class you have to use the scope resoulion operator (::). Consider the following example:

void Circle::getdata(){ 
  cout<<"Enter the radius: "<<endl; cin>>r; 
}

Access Specifiers

They are used to specify which functions can access the data of a function. Private is an access specifier that is used to secure the data to restrict the other functions from accessing the data in a function. If you use the 'public' access specifier it can exchange the data with other functions and classes. If you don't specify anything, C++ will consider it as private.

Objects

Now to access those functions you need to create an object. To create an object you have to do it in the main function. You have to specify the name of the class. For example,

int main(){ 
  Circle c1; 
  c1.getdata(); 
  c1.area(); 
  getch(); 
  return 0;
}

Advantage of using classes

Suppose you have a large program to write which has to have a whole lot of functions. Then you can use the concept of classes. You can include all the same type of functions in one class. Then create objects for the class in the main function and use the objects. This will make the program more organized and easy to code.

DYNAMIC MEMORY ALLOCATION:

Dynamic memory allocation is the means by which a program can obtain memory while it is running. Global variables are allocated storage at compile time. Nonstatic , local variables use the stack. However, niether global nor local variables can be added during program execution. Yet there will be times when the storage needs of a program cannot not known ahead of time. For example , a program might want to use a dynamic data structure,such as a linked list or a binary tree.Such structures are inherently dynamic in nature,growing and shrinking as needed. To implement such a data structure requires that a program to be able to allocate and free memory as needed.

Memory allocated by c’s dynamic allocation functions is obtained from the heap. The heap is free memory that is not used by your program,the os,or any other proram running in your computer. The size of the heap cannot usually be known in advance,but it typically contains a very large amount of free memory.

The following functions are used in C for dynamic memory allocation:

  1. Alloc ( ): The alloc function is used to aloocate a region or block of size bytes in length of the heap. The general declaration of the alloc() function is:

Char *alloc(size)

Unsigned int size;

Some C compiler versions fill the allocated region with zeros. All versions return some kind of an error when there is no more space left to allocate, either 0,-1 or printing a message to the system   .

  1. Malloc ( ): The malloc () function is used to allocate heap storage. Its name stands for memory allocation .The allocated regiojn is not filled with zeros. The starting address is returned if the function is successful. A zero is returned if the function attempts to get a block of memory fails

Char *malloc(size)

Unsigned int size;

  1. Calloc ( ): The calloc function is used to allocate the continuous memory or element by element basis. The name stands for calculated allocation.It is useful in arrays and array like structures where continuity of memory is required. The starting address of the area is returned if the function is successful.A zero is returned if the function attempt to get a block a memory fails.

The general declaration of calloc function is given as:

Char *calloc(elements,element size)

Unsigned int elements;

Unsigned int element_size;

  1. Realloc (): The realloc function is used to increase or decrease the size of the block of heap memory to the size , specific by size preserving the address and contents of the beginning of the block. The function reealloc() can diminish the size of the allocated area.

The general declaration of realloc() function is:

Char *realloc(old block,size)

Char *old block;

Unsigned int size;

The realloc function returns the address of the newly allocated region which is same as the old block. It returns a zero if an attempt to create a new block is unsuccessful.

  1. Free(): the free function is used to free a portion of storage within the heap previously allocated by alloc(),malloc(),calloc(),or realloc(). The storage returns to heap,making it available for further heap activity. The pointer that is the arguments to free() is the starting address for the region allocated.

Its general declaration is:

Int free (pointer)

Char *pointer;

 

 

 



 

This is a technique to sort a given array in an acending order.

Here is the steps we follow while performing quick sort :-

  1. The last element of array is assumed to be "infinity".
  2. " i " (which is an integer type variable) point to the lowest index and " j " (another integer type variable) points to the highest index of the array.
  3. First element is assinged asthe "pivot" element.
  4. " i " is incremented till larger or equal element than pivot is found.
  5. " j " is decremented till smaller or equal element then pivot is found.
  6. If " i " is less than " j " then interchange a[i] with a[j] and repeat the steps 4 and 5, else interchange a[j] and "pivot".

When the element (a[j])  is exchanged with "pivot" then the position of that element is fixed in the array and divides the array into two parts ie. on the right of the array all maximum elemnts will be there and on the left of the array all minimum elements will be there. Now sort the two parts in the same manner as of the parent array.

Now as we see that the no. of iterations will be " n log2(n )" since " 2x " times of comparison is made in one iteration and total number of iterations is "n", hence the total number of iterations will be " n X 2x " ie. " n log2(n) ".

Hence, the complexcity of this sorting technique is n log2(n).

" n " here is the size of the array.

Now we will discuss how did the term log2(n) came.

Since 2x iterations are made and in the worst case the "2x = n".

Then,

x = log2(n)

Where " log2 " refers to the base of logarithmic function ie. 2.

Hope when you read this article your understanding will we enhanced and you will be able to write the coding efficiently.

When objects are declared that is constructed for a particular class then this objects will occupy certain memory locations. The data members of these objects will have garbage values. In object oriented applications we will prefer that this values should not be garbage rather the datamember of the objects should be automatically initialised with some predefined values. 

For eg:- When we declare object of class count we will prefer its initial value to be zero than garbage. Similarly if we declare object of class abc we may prefer the side of the abc as units than the garbage ( unit abc)The constructors are the fn which are used for automatic initialization of data members of the objects.
Constructors function:

The constructor fn is a fn that has got same name as that of the class.

→ The constructor fn do not have any return type not even void.
→ The constructor fn is also called automatically for the object. When the object is declared that is constructed.
→  The construction function is to be declared as public member function of the class.
→  The constructor function is useful for automatic initialization of datamembers of the objects.
→  The constructor function can be declared without parameter.
→  The constructor function can be declared with parameter.
→ We can declare multiple constructions within a single class.
→ It is possible to declare constructor with default parameter.
→ The constructor function can be called explicitly as other member function.

Construction function without parameter / default constructor:

Develop a class cube with data member side. The class should have following member function.

Setside ( ) ; 2) getside ( ) ; 3) display ( ) ; 4) A function to calculate and return the volume of the cube. 5) a construction fn that will initialize side of the cube with 1

Write suitable main fn:
# include
class cube ;
{
int side ;
public:
void setside (int) ;
void getside ( ) ;
void display ( ) ;
int volume ( ) ;
cube ( ) ;
};
{
cube :: cube ( ) ;
side=1 ;
}
void cube :: setside ( int s )
{
side = s ;
}
void cube :: display ( )
{
cout<<"side= "<
}
int cube :: volume ( )
{
return side x side x side ;
}
void main ( )
{
cube C1 ;
C1.display ( ) ;
cout<<"volume="<
C1.setside (5) ;
C1. display ( ) ;
cout<<"volume="<
}
side=1
volume=1
side=5
volume=125.

In the above program we declare constructor function without parameter.
Consider the declaration cube C1; with this statement we declare i.e. we construct object C1 of class cube. Memory space of two bytes will be allocated for the object ( ). The constructor fn gets called automatically for the object C1. And hence C1. Side will be initialized with value 1. Thus automatic object initialization with predefined value is obtained using constructor fn.

Limitation:-
In the above program whenever object of class cube is constructed its side will be automatically initialized with 1. It is better than having the garbage value for the side. However the limitation is the side will be compulsorily initialized with one. We overcome this limitation by writing constructor with parameter.

 

Overloading constructors :

 Develop a class cube whose description is very similar to the previous program. The only difference is define 2 construction fn within this class. One without parameter and other with parameter. Write suitable main fn.

# include

class cube
{
int side ;
public:
void setside (int) ;
void getside ( ) ;
void display ( ) ;
int volume ( ) ;
cube ( ) ;
cube (int) ;
};
cube :: cube ( )
{
side=1 ;
}
cube :: cube (int 5)
{
side=5 ;
}
void cube :: setside (int s)
{
side=s ;
}
void cube :: getside ( )
{
cin>>side ;
}
void cube :: display ( )
{
cout<<"side="<
}
int cube :: volume ( )
{
return side*side*side ;
}
void main ( ) ;
{
Cube C1, C2 (4), C3=5 ;
C1.display ( ) ;
Cout<<"volume="C1.volume ( ) <<'\n' ;
C2.display ( ) ;
Cout<<"volume="<
C3.display ( );
Cout<<"volume="<
}
Side=1
volume=1
side=4
volume=6
side= 5
volume=125.

In the above class we have declare two constructors one with without parameter and other with parameters.

Consider the statement.
C1, C2 (4), C3=5 ;
For object C1 constructor without parameter will be called and C1 side is initialised with 1.
For object C2 the value 4 is passed as parameter. Hence the constructor with parameter will come in picture and C2. Side will be initialized with 4.
For object C3 the values 5 is treated as parameter hence the constructor with parameter will be called automatically and C3.side will be initialized with 5.
Constructor with default parameter. The 2 constructor fn in the previous program can be replaced with a single a constructorwith default parameter. It will give the same effect as that of two independent constructors.

# include
class cube
{
int side ;
public:
: : : :
: : : :
};
cube :: cube (int 5 )
{
Side=5 ;
}

The body of set side, get side, display, volumes main will be same as that of the previous program.
Explanation:-
For object C1 since the parameter is not passed the constructor will utilized default value and hence C1.side = 1, for object C2 and C3. Since the parameter is present the default value will not be ustilised and C2.side and C3.side will be initialized with 4 and 5 respectively.

Dynamic initialization using constructor:-

Explicit call of the constructor.Develop a class counter with data member count.

The class should have following member fn: 
get count ( ) 2) display ( ) 3) increment ( ) 4) decrement ( ) 5) A constructor function that will intilise the count with the accepted value and if the value is not supplied the count should be initialized with zero.

 

Write suitable fn that will explain dynamic initialization using constructor.

# include

class counter
{
int count ;
public:
void getcount ( ) ;
void display ( ) ;
void increment ( ) ;
void decrement ( ) ;
counter (int=0) ;
};
void counter :: get count ( )
{
cin>>count ;
}
void counter :: increment ( )
{
count ++ ;
}
void counter :: decrement ( )
{
count - - ;
}
void counter :: display ( )
{
cout<<"count="<
}

counter :: counter int ( )

{

counter= 1 ;

}

void main ( )

{

counter C1,C2 (32) ;

C1.display ( ) ;

C2.display ( ) ;

C1.increment ( ) ;

C1.display ( ) ;

C2.decrement ( ) ;

C2.display ( ) ;

C2=counter (50) ;

C2.display ( ) ;

C1.counter (10) ;

C1.display ( ) ;

}

C2=counter (50) ;

In the above statement the constructor fn is called explicitly for object C2 and 50 is passed as parameters. The C2.count is initialized with 50.the C2.count is initialized when the program is running. Thus the dynamic initialization is obtained using the constructor function. Similar explanation is applicable for C1.counter (10);


    Copy constructor:

Consider the following eg:-

# include
Class pqr
{
int data ;
public:
void display ( ) ;
pqr ( int=0) ; // Normal constructor
pqr (pqr &) ; // Copy constructor
};
void pqr :: display ( )
{
cout<

}
pqr :: pqr (int d)
{
data=d ;
}
pqr :: pqr (pqr &t)
{
data=t.data ;
}
void main ( )
{
pqr P1,P2 (3) ; // Normal constructor

P1.display ( ) ;

P2.display ( ) ;

Pqr P3 (P2) ; // copy constructor.

P3.display ( ) ;

Pqr P4=P1 ; // copy constructor

P4.display ( ) ;

Pqr P5 ; // Normal constructor

P5.display ( ) ;

P5=P4 ; // Assignment process.

P5.display ( ) ;
}
he constructor that excepts alias of object of same class is called as copy constructor.

Consider the statement ;

pqr p3 (p2) ;

In this statement we declare that we construct P3 and object P2, is passed as parameter. The copy constructor will be called for P3. The t will act as alias of P2.value of t.data i.e. P2 data = 3 is copied into data i.e. P3.data.
Thus we get the copy of P2 into P3. and hence the copy constructor.
Similar explanation is applicable for Pqr P4=P1; due to this statement the copy constructor will gives us copy of P1 into P4. P5=P4;
The value of P4.data will be copied into P5.data with the normal assignment process.

Detructor Function :
  1. The destructor has got same name as that of the class.
  2. The destructor do not have any return type not even void
  3. The name of the destruction fn will be proceed i.e. preferred with the  character
  4. The destructor fn will called automatically when the objects are deallocated i.e. destructed from the memory.
  5. The destructor also comes in picture when dynamically allocated objects are made free i.e. deleted.

Develop a class counter with datamember count.one class will have following member fn

get count ( ) ; display ( ) ; increment ( ) ; decrement ( ) ;

constructor with default parameter destructor fn with appropriate logic.

# include class counter { int count ; public: void getcount ( ) ; void display ( ) ; void increment ( ) ; void decrement ( ) ; counter ( int=0 ) ; ~ counter ( ) ; }; void counter :: getcount ( ) { cin>>count ; } void counter :: display ( ) { cout<

}

counter :: counter int ( )

{

count=c ;

}

counter :: ~ counter ( )

{

cout<<"object with value"<
}

void counter :: increment ( )

{

count ++ ;

}

void counter :: decrement ( )

{

count - - ;

}

void main ( )

{

counter C1,C2 (10), C3 (25) ;

C1.display ( ) ;

C2.display ( ) ;

C3.display ( ) ;

C1.increment ( ) ;

C1.display ( ) ;

C2.decrement ( ) ;

C2. Display ( ) ;
}

O/P:- 0

10

25

1

9
Object with value 25 will be destructed object with value a will been destructed object with value has been destructed.
Explanation:
→   In the above program we declare destructor function within the class counter. In the main function we declare i.e we construct objects C1,C2 and C3. Constructor fn will be called automatically for all the three objects in the order C1,C2, and C3.
→   When main fn is about to finish then the complies will understand that the objects are deallocated from the memory. The destructor fn will be called automatically for all the three objects in the order C3, C2,and C1. For every object the destructor fn is called first and once the destructor fn execution is finished the corresponding object is deallocated from the memory.


Develop a class to represent complex number. The class should have following member function.
  1. A fn to get the CN from user.
  2. A fn to display the CN
  3. A fn to add the two CN which are accepted as parameters.
  4. Multiply
  5. Subtract
  6. Divide
   
Write suitable main fn.
Program :-
#include
class complex
{
float r, i ;
Public:
void getcomplex ( ) ;
void display ( ) ;
void add (complex, complex) ;
void subtract ( complex, complex) ;
void multiply ( complex, complex) ;
void divide ( complex, complex) ;
};
void complex :: get complex ( )
{
cin>>r>>i;
}
void complex :: display ( )
{
cout<
}
void complex :: add (complex x, complex y)
{
r=x.r+y.r ;
i=x.i+y.i ;
}
void complex : subtract (complex x, complex y)
{
r= x.r – y.r ;
i= x.i – y.i ;
}
 
void complex : multiply (complex x, complex y)
{
r= x.r * y.r – x.i * y.i ;
i = x.i * y.r + x.r * y.i ;
}
void complex :: divide (complex x, complex y)
{
r=(x.r*y.r+x.i*yi) / (y.r*y.r+y.i+y.i) ;
i=(x.i*y.r –x.r*y.i) / (y.r*y.r+y.i*y.i) ;
}
Logic:-        x.r x.i                   y.r y.i
(a+ib)                   (c+id) *
=   (ac-bd) + i (bc + ad)
a+ib
c+id
=       a+ib .         c−id
c+id            c−id *
=       (ac+bd) + i (bc−ad)
(c2+d2)
Void main ( )
{
complex c1,c2, a, s, m, d ;
cout<<"Enter complex numbers="<<'\n' ;
cn.get complex ( ) ;
cout<<"Enter complex Number = "<<'\n' ;
 
c2. get complex ( ) ;
a. add ( c1, c2) ;
s. subtract (c1,c2) ;
m. multiply (c1,c2) ;
d. divide (c1,c2);
cout<<"Addition \n" ;
   
a.display ( ) ;
cout<<"Subtraction\n" ;
s.display ( ) ;
cout<<"multiplication\n" ;
m.display ( ) ;
cout<<"division\n";
d.display ( );
}

Method II

 

Addition of two CN.

 

#include

 

class complex

 

{

 

float r, i ;

 

public:

 

void getcomplex ( );

 

void display ( );

 

complex add (complex);

 

complex subtract (complex);

 

complex multiply (complex);

 

complex divide (complex);

 

};

 

void complex :: get complex ( )

 

{

cin>>r>>i;

 

}

 

void complex :: display ( ).

 

{

 

cout<

 

}

 

complex complex :: add (complex c)

 

{

 

complex temp;

 

temp.r = r+c.r;

 

temp.i = i+c.i;

 

return temp ;

 

}

 

complex complex :: multiply (complex c)

 

{

 

complex temp;

 

temp.r = r * c.r – i * c.i ;

 

temp.i = i * c.r + r* c.i ;

 

return temp ;

 

}

 

complex complex :: divide (complex c)

 

{

 

temp.r = (r*c.r + i * c.i) / ( c.r*c.r+c.i+c.i)

 

temp.i = (1*c.r – r* c.1) / (c.r*c.r+c.i*c.i) ;

 

return temp ;

 

}

 

complex complex :: subtract (complex)

 

{        temp.r = r – c.r ;

 

temp.i = i – c.i ;

 

return temp ;

 

}

 

void main ( )

 

{

complex c1, c2, a, s, m, d ;

 

cout<<"Enter CN = \n" ;

 

c1.getcomplex ( ) ;

 

cout<<"Enter CN = \n" ;

 

c2.get complex ( );

 

a = c1.add (c2) ;

 

s= c2.sbutract (c2) ;

 

m = c1.multiply (c2) ;

 

d = c1.divide (c2) ;

 

cout<<"Addition=\n" ;

 

a.display ( );

 

cout<<"subtraction=\n";

 

a.display ( ) ;

 

cout<<"multiplication = \n" ;

 

m.display ( ) ;

 

cout<<"division=\n" ;

 

d.display ( );

 

}

 

More Articles …

  1. Friend function And Friend Class
  2. Concept Of Data hiding & Encapsulation In C++
  3. STRUCTURES IN C++
  4. Function with default parameters (arguments)

Page 1 of 21