Classes and Objects in C++

Classes

A class binds data describing an entity and its associated functions together.

Ex.
An account having characteristics account no, type and balance .Its associated operations are deposit and withdrawal.

Its class defined as follows
 class Account {int accno;
                           char type;
                           float bal;
                           float deposit(float amount)
                                 {
                                    bal+=amount;
                                     return bal;
                                 }
                           float withdraw(float amount)
                                 {
                                   bal-=amount;
                                    return bal;
                                 }
                          };

                     
Declaration of classes

Declaration of class evolves four associated functions-

1.      Data members are the data type properties that describe the characteristics of class; it may be zero or many.

2.     Member functions are the set of operations that may be applied to objects of that class.

3.    Program access levels these are public, private, protected to describe the access level of the class.

4.    Class tagname that specify the type of object that class have.

Note-by default all the members of the class are private.

• Defining a class-
  

class salesman{
                           int salesman_no;
                           char s_name[25];
                           int pro_no;
                           float tar, sales_made,comm;
                           void calc_com(void);
                          public:
                            void readData();
                            float addman_sale(float sales);
                            void printData();
                          }  

· The class method’s(member function) Definition

The class member can be define in two places
1. Outside the class definition
2. Inside the class definition

1. outside the class definition

The definition of the member function outside the class is given by its qualified name (with class name)

This is done by :: (symbol),called scope resolution operator, which shows that the function is restricted to the class?

Syntax
return-type class-name:: function-name(parameter list)
{
  Function body;
}
Ex. void salesma::readData()
         {
           cout<<"Enter Salesman no:";
           cin>>salesma_no;
           cout<<"Enter salesman name";
           gets(s_name);
           cout<<"Enter Product_no";
           cin>>pro_no;
           cout<<"Enter target and sales made";
           cin>>tar>>sales_made;
           }   

2. Inside the class

The function definition inside the class defined in general way

 class sample {
                          int a;
                          int b;
                          public:
                          int add()
                          {
                            cout<<"Enter the value of a and b";
                            cin>>a>>b;
                            return a+b;
                          }
                         void print()
                          {
                             int c;
                             c=add();
                             cout<<"This is addition"<<add();
                           }
                        };   
  

· Referencing class member/declaration of object as instance of class

To make use of class specified, the variables of the class type have to be declared.
For eg. sample s1,s2;

The members of the class are referenced using object of class.
Ex.
     class Abc{ int x,y;
                         public:
                                   int z;
                                   int add(int a, int b)
                                     {
                                         int c=a+b;
                                         return c;
                                     }
                         };
      Abc O1;   

 
The private data can be accessed only through member function. But public data can be accessed through the object of class by non-member-function. The general form for calling member function is:

object-name. function-name (actual-arguments);
object-name. public data-member ;

Ex.   
O1.add(2,3);
O1.z=7;                                      //valid
O1.x=5;                                  //invalid
O1.y=3;                                  //invalid

·        Program to illustrate the working of class and object and private and public modifier
 
 #include <iostream.h>
          class x {
                           private:
                                   int a;
                                   int sqr(int a)
                                      {
                                         return a*a;
                                      }
                         public:
                                 int b;
                                 int twice(int i)
                                      {
                                         return i*2;
                                       }
                                   int tsq(int i)
                                     {
                                        int p=sqr(i);                       //private function being                                                                 int q=twice(p);                   being invoked by a member                                                         return q;                               function                                                                                             

                                    }
                           };
                       x ob;
                    
                     void main()  
                      {
                            ob.b=5;                                              //'b' is a public member
                             ob.a=2;                                            // wrong!
                             ob.twice(10);                                  //twice() is a public
                             ob.sqr(10);                                      //wrong! 
                              ob.tsq(10);                                    //tsq()  is public 
                        } 

    When a member function called by another member function it is called nesting of member functions. 

· Global object

A global object is declared outside of all the function bodies and this object can be used anywhere in the program.

Ex.
  #include<iostream.h>
      class x                                                                   \\Global class
              {
                   public:
                        int a;
                        void fun();
               };
   x obj;                                                                         \\Global object
      void main()
           {
              x obj2;
              obj.a=10;                                                          \\valid
               obj.fun();                                                          \\valid
           }
     void func()
          {
             obj2.a=30;                                                            \\invalid
             obj.a=20;                                                               \\valid
             obj.fun();                                                                 \\valid 
          }   

        
                     

· Local object

A local object is declared within the function; mean that its object is used in the function, which declares it, not outside the function.

Ex.
#include<iostream.h>
  class x                                                    //Global class
   {
     public:
        int a;
        void fnc(void);
    };
 void main()
   {
      class y
        {
           public:
           int i;
           void fc(void); 
       };
 x ob1;                                                          //local object of global class
 y ob2;                                                          //local object of local class
 ob1.a=5;
 ob1.fnc();
 ob2.i=15;
 ob2.fun();
 }
void funct(void)
{
  x ob3;
  y ob4;                                                         //invalid
  ob3.a=25;                                                 //valid
  ob3.fnc;                                                    //valid
  ob1.a=10;                                                 //invalid
  ob2.fc();                                                   //invalid
}

· Program to illustrate the working of class and object.

      #include<iostream.h>
       class temp
       {
          int s1;
          float s2;
          public:
              void int_data(int d)
                    {
                          s1=d;
                          cout<<"Number:"<<s1;
                          }
                   float float_data()
                       {
                           cout<<"\n Enter data:";
                           cin>>s2;
                          return s2;
                       }
         };
      void main()
          {
             temp t1,t2;
              t1.int_data(12);
              cout<<"You entered:"<<t2.float_data();
           }

        
       output:-
                      Number:12
                      Enter data:12.43
                       You entered:12.43

· Program to calling overloaded function test

          #include<iostream.h>
           void test(int);
           void test(float);
           void test(int,float);
           void main()
             {
                 int a=5;
                 float b=5.5;
                 test(a);
                 test(b);
                 test(a,b);
            }
         void test(int var)
           {
                cout<<"Integer number:"<<var<<endl;
           }
        void test(float var)
          {
             cout<<"Float number:"<<var<<endl;
          }
        void test(int var1,float var2)
          {
             cout<<"Integer Number:"<<var1<<"And float number:"<<var2;    
          } 

· Object as function arguments

1. By value
2. By reference
1. By value

When the object is passed by value, the function creates its own copy of the object and works with its own copy. Therefore, any changes made to the object inside the function don’t affect the original object.

Ex.
#include<iostream.h>
  class rational
      {
          private:
             int num,dnum;
          public:
              void get()
                 {
                      cout<<"Enter numerator";
                      cin>>num;
                      cout<<"Enter denomenator";
                      cin>>dnum;
                 }
           void print()
                 {
                     cout<<'num'<<"\"<<dnum<<endl;
                 }
         };
   void rational multi(rational r1,rational r2)
        {
            num=r1.num*r2.num;
            dnum=r1.dnum*r2.dnum;
        }
   void main()
       {
            rational r1,r2,r3;
            r1.get();
            r2.get();
            r3.multi(r1,r2);
            r3.print();
       }    





This post is about Classes and Object in C++ .In the next post we will talk about Constructors and Destructors.