C++|| STATIC DATA MEMBER AND FUNCTION || ACCESS MODIFIERS|| FRIEND FUNCTION

C++

Static data member and static member function

STATIC DATA MEMBER -

A data member of class can be qualified as a static the properties of static member variable are similar to c static variable. static variables are normally use to maintain the record of an object.

properties:

i)it is initialialized to 0 when the first object of its class is created.

ii)only one copy of that member is created for the entire class and share by all the object of that class no matters how many objects are created.

iii)it is visible only within the class but its lifetime in the entire program.

e.g-

Q) write a program in c++ using static member function to count  the numbers.

--->

#include<iostream.h>
#include<conio.h>
class item
{
static int count;
int number;
public:
void getdata(int a)
{
number=a;
count++;
}
void getcount()
{
count<<"count"<<count;
}
};
int item::count
void main()
{
item a,b,c;
a.getcout();
b.getcout();
c.getcout();
a.getdata(100);
b.getdata(200);
c.getdata(300);
cout<<"after reading data";
a.getcout();
b.getcout();
c.getcout();
getch();
}

output-- 0
              0
              0
after reading data
             3
             3
             3

STATIC MEMBER FUNCTION

i)if any function become static function is called by class name.
ii)static member function can access only static data member.

e.g-

class test
{
int code;
static int count;
public:
voidd setcode()
{
code=count++;
}
void showcode()
{
cout<<"object number "<<code;
}
static void showcount()
{
cout<<"count"<<count;
}
};
int test::count;
int main()
{
Test t1,t2;
t1.setcode();
t2.setcode();
test::showcount();
test t3;
t3.setcode();
test::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
getch();
}

ACCESS MODIFIERS

There are three type of access modifier in c++.

1) public.
2) private.
3)protected.

• public key- public can access inside the class as well as out side the class                                       
• private key- private member can access inside the class only.                                                        
• protected key- protected member can access inside the class as well as the  class which is derived from it. 

e.g -

class A
{
private:
//only access inside the class.
public:
inside as well as outside.
}s;

class A
{
// by default private.
public:
}

class A
{
// by default all become private;
};

----------------------------------------------------

INSIDE CLASS DEFINATION AND OUTSIDE CLASS DEFINATION


member function can be defined in two ways

1)inside the class defination.
2)outside the class defination.

• inside the class defination - the fun which is define inside the class is called inside the class defination.

e.g -

#include<iostream.h>
#include<conio.h>
class item
{
private:
int number;
float cost;
public:
void getdata()
{
cout<<"enter number and cost ";
cin>>number>>cost;
}
};
void main()
{
item I;
I.getdata();
I.putdata();
getch();
}
--------------------------------------------------------

• outside the class defination -- the function which is define outside the class is called outside the class defination.

e.g-

#include<iostream.h>

#include<conio.h>
class item
{
private:
int number;
float cost;
public:
void getdata();
void putdata();
};
void item::getdata()
{
cout<<"enter number and cost";
cin>>number>>cost;
}
void item::putdata()
{
cout<<number<<cost;
}
void main()
{
Item I;
I.getdata();
I.putdata();
getch();
}
-----------------------------------------------------

FRIEND FUNCTION

PROPERTIES OF FRIEND FUNCTION                                                                                                 

• if any function is specified by keyword friend that function is called friend function.
  
• friend function can be declared either in public or private function.                                                         
• friend function is not a memer of that class because it is a friend.                                                                                               
• whenever the friend function is defined outside the class we should not mention the class name or scope resolution(::) operator because that function is not a member of that class.                                
• if any function becomme a friend that function should have object as a function argument.                     
• friend function cannot be call by object it is automatically invoked.                                                       
• friend function can only declared in the class and it is defined outside the class.                  

syntax - 

class A

{

void getdata();

void putdata();

}
class B

{
friend void A:putdata();//only one member is friend.

};

class B

{
friend class A; //A member is friend.

};

---------------------------------------

Q)write a program to find the maximum of two number using friend function inn two classes.

--->

#include<iostream.h>
#include<conio.h>
class ABC; //forward declaration.
class xyz
P{
int x;
public:
void setvalue(int a)
{
x=a;
}
friend void max(xyz m,ABC n);
};
class ABC
{
int y;
public:
void setval(int b)
{
y=b;
}
friend void max(xyz m,ABC n)
{
if(m.x>=n.y)
{
cout<<"maximum is"<<m.x;
}
else
{
cout<<"maximum is"<<n.y;
}
}
void main()
{
ABC P;
P.setval(10);
xyz q;
q.setval(20);
max(p,q);
getch();
}
-----------------------------------------------------------------------------------------------------------
Q)define a class fraction having integer data member numerator and denominator. define parametrized and default constructor. write the main function to illustrate the use of class.

--->

#include<iostream>
namespace std;

class fraction
{
private:
int numerator.denominator;
int gcd();
public:
fraction(int n=0,int d=1);
void display()
fraction addition(fraction,fraction)
fraction substraction(fraction,fraction)
fraction multiplication(fraction,fraction)
fraction division(fraction,fraction)
};
fraction::fraction(int n,int d)
{
numerator=n;
denominator=d;
if(d!=1)
{
int g=gcd();
numerator=numerator/g;
denominator=denominator/g;
}
int fraction::gcd()
{
int a=numerator.b=denominator;
while(a!=b)
{
if(a>b)
a=a-b;
else
b=b-a;
}
return(a);
}
void fraction::display()
{
cout<<numerator<<"/"<<denominator<<endl;
}
fraction fraction::addition(fraction obj,fraction obj1)
{
fraction temp(numerator*obj1.denominator+denominator*obj1.numerator,denominator*obj1.denominator);
return(temp);
}

fraction fraction::subtraction(fraction obj,fraction obj1)
{
fraction temp(numerator*obj1.denominator-denominator*obj1.numerator,denominator*obj1.denominator);
return(temp);
}

fraction fraction::multiplication(fraction obj,fraction obj1)
{
fraction temp(numerator*obj1.numerator,denominator*obj1.denominator);
return(temp);
}

fraction fraction::multiplication(fraction obj,fraction obj1)
{
fraction temp(numerator*obj1.numerator,denominator*obj1.denominator);
return(temp);
}

fraction fraction::multiplication(fraction obj,fraction obj1)
{
fraction temp(numerator*obj1.numerator,denominator*obj1.denominator);
return(temp);
}

fraction fraction::multiplication(fraction obj,fraction obj1)
{
fraction temp(numerator*obj1.denominator,denominator*obj1.numerator);
return(temp);
}

int main()
{
int num,demo;
cout<<"enter first fraction:";
cin>>num>>demo;
fraction f1(num.demo);
cout<<"enter second fraction:";
cin>>num>>demo;
fraction f2(num.demo);
fraction f3,f4,f5,f6;
f3=f1.addition(f1,f2);
f4=f1.subtraction(f1,f2);
f5=f1.multiplication(f1,f2);
f6=f1.division(f1,f2);
cout<<"the addition is":
f3.display();
cout<<"subtraction is ";

f4.display();

cout<<"the multiplication is ";
 f5.display();
cout<<"the Division is";
f6.display();
return (0);
}

output -

enter first fraction: 5 2
enter second fraction: 3 8
the addition is 23/8
the subtraction is 17/8
the multiplication is 15/16
the Division is 20/3