C++
This document was uploaded by user and they confirmed that they have the permission to share it. If you are author or own the copyright of this book, please report to us by using this DMCA report form. Report DMCA
Overview
Download & View C++ as PDF for free.
More details
- Words: 4,317
- Pages: 74
#include//CLASS DEMONSTRATION class item { int number; float cost; public: void getdata( int a, float b) void putdata(void) { cout<<“number :”<
void main( ) {item x; cout<<“\nobject x “<<“\n”; x.getdata(100,290.5); x. putdata( ); item y; cout<<“\n object y”<<“\n”; y.getdata(200,220.78); y.putdata( ); } object x number:100 cost: 290.5 object y number : 200 cost : 220.78
Nesting of Member Functions
#include class Set { int m, n; public: void input(void); void display(void); int largest(void); }; int set :: largest(void) { if( m>=n) return m; else return n; }
void set :: input(void) { cout<<“Input values of m and n”<<“\n”; cin>>m>>n; } void set:: display(void) { out<<“Largest value=“<
//STATIC CLASS MEMBER #include class item
{ static int count; int number;. public: void getdata(int a) {number=a; count++; } void getcount(void) { cout<<“count:”; cout<
int item :: count;
void main() { item a, b, c; a.getcount(); b.getcount(); c.getcount(); a.getdata(100); b.getdata(200) c.getdata(300) cout<<“After reading data”<<“\n”; a.getcount(); b.getcount(); c.getcount(); }
Output Screen: count:0 count:0 count:0 After reading data count:3 count:3 count:3
Static Data Members It is initialized to zero when the first object of its class is created. No other initialization is permitted. Only one copy of that member is created for the entire class and is shared by all the object of that class, No matter how many object are created. It is visible only within the class, but its lifetime is the entire program.
#include class test { int code; static int count; public: void setcode(void) { code =++count; } void showcode(void) { cout<<“Object Number:”<
void main() { test t1,t2; t1.setcode(); t2.setcode(); test :: showcount(); test t3; t3.setcode(); test t3; t3.setcode(); test :: showcount(); t1.showcode(); t2.showcode(); t3.showcode(); }
Output of theprogram:count:2 count:3 object number:1 object number:2 object number:3
Static Member Functions A static member functions can have access to only other static members( functions or variables) declared within the same class. A static member function can be called using the class name( instead of its objects) as follows class-name :: function-name;
#include class employee { char name[30]; float age; public: void getdata(void); void putdata(void); }; void employee :: getdata(void) { cout<<“Enter Name”; cin>>name; cout<<“Enter age”; cin>>age; } void employee ::putdata(void) { cout<<“Name: ”<
void main() { employee manager[size]; for(int i=0,i<size;i++) { cout<<“Details of Manager”<
Output Details of Manager 1 Enter name:XXX Enter age:45 Details of Manager 2 Enter name:YYY Enter age:35 Manager 1 Name: XXX Age: 45 Manager 2 Name: YYY Age: 35
//Passing Objects as Coordinates #include class time {int hours,minutes; public: void gettime(int h, int m) {hours=h; minutes=m;} void puttime(void) { cout<
void main() { time T1,T2,T3; T1.gettime(4,45); T2.gettime(3,30); T3.sum(T1,T2); cout<<“T1 = “; T1.puttime( ); cout<<“T2 = “; T2.puttime( );. cout<<“T3 = “; T3.puttime( ); }
Output: T1 = 4 hours 45 minutes T2 = 3 hours 30 minutes T3 = 8 hours 15 minutes
Friendly Functions A friend function possesses certain special characteristics: It is not in the scope of the class to which it is declared as friend. Since it is not in the scope of the class it cannot be called using the object of that class. It can be invoked like a normal function without the help of any object. Unlike member functions, it cannot access the member names directly and has to use an object name and dot membership operator with each member name It can be declared either in the public or private part of a class without affecting its meaning. Usually, it has objects as arguments.
class sample { int a; int b; public: void setvalue( ){a=25;b=40;} friend float mean(sample s); }; float mean( sample s) { return(s.a+s.b)/2; }
void main() { sample X; X.setvalue(); cout<<Mean Value=“<<mean(X)<<endl; } Output: Mean value=32.5
The constructor function has the following characteristics:They should be declared in the public section. They are invoked automatically when the objects are created. They do not have return types not even void and therefore they cannot return values. They cannot be inherited though a derived class can call the base class constructor. Like any C++ function they can have default arguments. Constructors cannot be virtual. We cannot refer to their addresses. An object with a constructor (or destructor) cannot be used as a member of the union. They make “ implicit calls” to the operators new and delete when memory allocation is required.
#include class complex { float x, y; public : complex( ){ } complex( float a ) {x=y=a;} complex( float real , float imag ) {x = real; y = imag ; } friend complex sum( complex , complex) friend void show( complex); }; complex sum( complex c1 , complex c2) {complex c3; c3.x=c1.x+c2.x; c3.y=c1.y+c2.y; return ( c3) ; }
void show( complex c) {cout<
Output: A=2.7+j3.5 B=1.6+j1.6 C=4.3+j5.1 P=2.5+j3.9 Q=1.6+j2.5 R=4.1+j6.4
Copy Constructor It is used to declare and initialize an object from another object A reference variable is used as an argument to the copy constructor. We cannot pass the argument by value to the copy constructor When no copy constructor is defined compiler calls its own copy constructor. The process of initializing through a copy constructor is called copy initialization.
# include class code { int id; public: code( ) { } code( int a) { id = a; } code( code & x) { id = x.id ; } void display (void) {cout<
void main() { code A(100); code B(A); code C = A; code D; D=A; cout<<“\n id of A : cout<<“\n id of B : cout<<“\n id of C : cout<<“\n id of D : } Output:id of A : 100 id of B : 100 id of C : 100 id of D : 100
” ; A.display( ) ; ” ; B.display( ) ; ” ;C.display( ) ; ” ;D.display( ) ;
Destructor:A destructor as the name implies is used to destroy the objects that have been created by a constructor. A destructor never takes any argument nor does it return any value It will be invoked implicitly by the compiler upon exit from the program(or block or function as the case may be) to clean up storage that is not accessible. It is a good practice to declare destructors in a program as it releases memory for future use.
# include int count = 0; class alpha { public : alpha( ) { count++ ; cout<<“\n SNo .of object created “ <
void main( ) { cout<<“\n \n Enter Main\n”; alpha A1, A2 , A3 , A4 ; { cout<<“ Enter BLOCK1”; alpha A5; } {cout<<“\n Enter BLOCK2”; alpha A6; } cout<<“\n Re-enter Main”; }
Output:ENTER MAIN. SNo .of object created 1 SNo .of object created 2 SNo .of object created 3 SNo .of object created 4 Enter BLOCK1 SNo .of object created 5 SNo .of object destroyed 5 Enter BLOCK2 SNo .of object created 5 SNo .of object destroyed 5 Re-enter Main SNo .of object destroyed 4 SNo .of object destroyed 3 SNo .of object destroyed 2 SNo .of object destroyed 1
# include class class2; // Known as forward declaration class class1 { int value1; public: void indata (int a) { value1=a;} void display (void) { cout <
void exchange(class1 & x , class2 & y ) { int temp = x.value1; x.value1= y.value2; y.value2 =temp; } void main( ) {class_1 C1; class_2 C2; C1.indata(100); C2.indata(200); cout<<“Values before exchange”<<“\n”; C1.display( ); C2.display( ); exchange(C1 , C2);
C1.display( ); C2.display( );
} Output:Values before exchange: 100 200 Values after exchange 200 100
Assignment:Programs 5.1 to 5.6(Debugging exercises do in the assignment copy) Program 5.1 5.2,5.5,6.2 and 6.3(Programming exercises take printout of programs and output)
Defrencing Operators:# incude class M { int x; int y; public: void set_xy( int a , int b ) { x = a; y = b ; } friend int sum( M m ); }; int sum( M m) { int M : : * px = & M : : x; int M : : * py = & M : : y; M * pm = &m; int S = m.*px + pm->*py; return S; }
void main( ) { M n; void ( M : : * pf)(int,int)=&M : :setxy; (n.*pf) ( 10 , 20); cout<<“SUM=“<<sum(n)<<“\n”; M * op = &n; (op->*pf)( 30, 40); cout<<“SUM=“<<sum(n)<<“\n”; } Output:sum = 30 sum = 70
Constructors They should be declared in public section. They are invoked automatically when the objects are created. They do not have return types, not even void and therefore, they cannot return any values. They cannot be inherited , though a derived class can call the base class constructor. Like any C++ functions , they can have default arguments. Constructors cannot be virtual. We cannot refer to addresses. An object with a constructor ( or destructor ) cannot be used as a member of union. They make ‘implicit calls’ to the operators new and delete when memory allocation is required. When a constructor is declared for a class ,initialization of the class objects become mandatory
Overloaded Constructors #include class complex { float x, y; public : complex( ) { } // Constructor with no arguments complex( float a ) { x = y = a ; } // Constructor with no arguments complex( float real , float imag )// Constructor with two arguments { x = real ; y = imag ; } friend complex sum (complex,complex); friend void show(complex); };
complex sum (complex c1 , complex c2) { complex c3; c3.x=c1.x+c2.x; c3.y=c1.y+c2.y; return (c3); } void show( complex c) { cout<
void main( ) {complex A ( 2.5, 3.5); complex B(1. 5 ); complex C; C = sum (A , B); cout <<“A = “ ;show( A ) ; cout<<endl; cout <<“B = “ ;show( B ) ; cout<<endl; cout <<“C = “ ;show( C ) ; complex P,Q,R ; P=complex(2.5,3.0); Q=complex(1.5,2.0); R=sum( P, Q); cout<<“\n”;
cout<<“\n”; cout<<“ P = “;show (P); cout<<endl; cout<<“ Q = “;show (Q); cout<<endl; cout<<“ R = “;show (R); cout<<endl; } Output:A = 2.5+j3.5 B = 1.5+j1.5 C= 4.0+j 5.0 P=2.5+j3.0 ; Q=1.5+j2.0 ; R=4.0+j5.0
Operator Overloading It allows to attach additional meaning to operators. The general form of an operator function is:return_type class_name: : operator symbol(argument list) { // task defined } The function operator op( ) is alwaus written in the public part of the class.It may be either a member function or a friend function
Overloading Unary Minus
void space : :getdata(int a,int b,int c) {x=a; # include y=b; class space z=c; { int x; } int y; void space : : display (void) int z; {cout<< x <<“ ”; public: void getdata(int a, int b,int c); cout<< y << “ “; cout<< z <<“ “ ; void display( void ); } void operator – ( ); void space : : operator-( ) }; {x = - x; y= - y; z= -z; }
void main( ) {space S; S.getdata(10,-20,40); cout << “S : “; S.display(); - S ; // activates operator- () function or S cout<< “ S : “; S.display( ) ; } Output:S : 10 -20 40 S : -10 20 -40
Overloading Binary + operator #include class complex { float x, y; public : complex( ) { } complex( float real , float imag ) { x = real ; y = imag ; } complex operator +(complex); void display(void); };
complex complex : : operator + ( complex c); {complex temp; temp . x= x + c. x; temp . y= y + c .y; return (temp); } void complex : : display(void) { cout<<x<< “ + j” <
void main ( ) { complex C1 , C2 ,C3; C1 = complex(2.5 , 1.5); C2 = complex(1.5 , 2.5); C3=C1+C2; cout<< “C1 = “; C1.display( ) ; cout<< “C2 = “; C2.display( ) ; cout<< “C3 = “; C3.display( ) ; } Output : C1 = 2.5 + j1.5 C2= 1.5 + j2.5 C3= 4.0 + j4.0
Rules for Overloading Operators:1. Only existing operators can be overloaded.New
operators cannot be created. 2. The overloaded operator must have atleast one operand. 3. We cannot change the basic meaning of an operator.That is to say that we cannot redefine the (+) operator to substract one value from the other. 4. Overloaded operators follow the syntax rules of original operators.They cannot be overridden. 5. There are some operators that cannot be overloaded. 6. We cannot use friend functions to overload certain operators. However ,member functions can be used to overload them.
Operators that cant be overloaded Sizeof Size of operator . Membership operator .* Point-to-member operator :: Scope resolution operator ?: Conditional operator Where a friend cannot be used = Assignment operator () Function call operator [] Subscripting operator -> Class member access operator
7. Unary operators overloaded by means of a member function take no explicit arguments and return no explicit values, but those overloaded by means of a friend function ,take one reference argument (the object of the relevant class).
8. Binary operators overloaded through a member function take one explicit argument and those which are overloaded through a friend function take two explicit arguments. 9. When using binary operators overloaded through a member function the left hand operand must be an object of the relevant class. 10.Binary arithmetic operators such as + , - , * , / must explicitly return a value.They must not attempt to change their own arguments.
Type Conversions // Basic to Class Type class Time { int hrs, mins; public: …………………. time( int t) {/* The constructors used for type conversion take a single argument whose type is to be converted.*/ hrs = t / 60; mins = t% 60; } }; time T1; int duration = 85; T1=duration;
//Class to Basic Type vector : : operator double( ) //Casting Operator Function {double sum = 0; for( int i = 0 ; i < size ; ++i) { sum = sum +v[ i ] * v [i ] ; } return sqrt(sum); } double length = double(V1); or double length = V1; Here V1 is an object of type vector The casting operator function should satisfy following conditions:It must be a class member. It must not specify a return type. It must not have any arguments.
One Class to Another Class Type # include class invent2 //Destination class declared class invent1 // Source class { int code; int items; float price; public : invent1(int a, int b , float c) {code = a ; items = b ; price = c ; }
void putdata( ) {cout<<“Code : “<
class invent2 { int code; float value; public : invent2( ) {code = 0; value = 0; } invent2( int x ,float y ) {code = x; value = y; } void putdata( ) {cout<<“Code:”<
invent2(invent1 p) {//constructor for conversion code = p . getcode( ); value = p.getitems( ) * p.getprice( ); } };// End of destination class void main ( ) { invent1 s1(100,5,140.0 ); invent2 d1; float total _value; //invent1 To float total_value = s1; /* invent1 To invent2*/ d1 = s1; cout<<“Product details – invent1 type”<<“\n”; s1.putdata () ;
cout<<“Product details-invent2 type”<<“\n”; d1. putdata( ) ; } Output:Product details-invent1 type Code: 100 Items: 5 Value: 140 Stock value value = 700 Product details – invent2 type Code: 100 Value: 700
void main( ) Object Pointers { item abc; class item item *ptr = &abc; { int cd; /* ptr is a pointer object of float cost; item class that is initialized public: with the address of another void getdata( int x , float y) object abc.*/ { cd = x; abc.getdata(26 , 150.50); cost = y; abc .show( ); } Or void show(void) ptr->.getdata(26 , 150.50); {cout<<“Code:”< .show( ); <<“Price:”<
Output:Code:26 Cost: 150.50 Code:26 Cost: 150.50 Code:26 Cost: 150.50
# include void main( ) {float amount; float value(float p, int t, float r = 0.15) amount = value(500.00, 5); //default for 3rd argument } float value(float p, int t, float r ) {int y = 1; float sum = p; /*Default values are specified when the function is declared*/
while (y< = t) {sum = sum + sum *r; y = y + 1; } return sum ; }/*Default arguments are useful when some argumets always have the same value .We must add defaults from right to left We cannot provide a default value in the middle of argument list.
Inheritance : Extending Classes Reusability is yet another feature of OOP. It is always nice if we could reuse something that already exist rather than trying to create the same all over again. It will not only save time and money but also reduce frustration and increase reliability Once a class has been written and tested ,it can be adopted by other programmers to suit their requirements.
This is basically done by creating new classes, reusing the properties of existing ones. The mechanism of deriving a new class from an old one is called inheritance (or derivation). The old class is referred to as the base class and the new one is called derived class or subclass.
Single Inheritance:A derived class with only one base class
A
B
Multiple Inheritance:A derived class with several base classes.
B
A
C
Hierarchical Inheritance:The traits of one class may be inherited by more than one class
A
B
C
D
Multilevel Inheritance:The mechanism of deriving a class from another ‘derived class’. A
B
C
The general form of deriving a derived class is:class derived-class-name : visibility-mode base-class-name { ……….// ............// members of derived class }; class ABC: private XYZ {members of ABC }; class ABC :public XYZ {members of ABC }; class ABC : XYZ {members of ABC };
Single Inheritance :PUBLIC # include class B { int a; public: int b; void get_ab( ); void get_a(void); void show_a(void); }; class D : public B { int c;
public:void mul(void); void display ( ); }; void B : :get_ab(void) {a = 5 ; b = 20 ; } int B : : get_a ( ) { return a ; } void B : : show_A ( ) {cout < <“A = “<
void D : : display( ) {cout<<“a = “<
d . b = 20; d.mul( ); d.display( ); } Output:a=5 a=5 b = 10 c = 50 a=5 b = 20 c = 100
void display(void); # include }; class B void B : : get_ab(void) { int a;//private not inheritable {cout<<“Enter a and b”; public : cin>>a>>b; int b; } void get_ab( ); int B : : get_a( ) { return a ; } int get_a(void); void B : : show_a( ) void show_a(void); {cout<<“a = “<
void D : : display ( ) { show_a( ); cout<<“b = “<
// d . b = 20; d . mul( ); d.display( ); } Output:Enter values of a and b:
5 10 a=5 void main ( ) b = 10 { c = 50 D d; Enter values of a and b: // d. get_ab( ); WON’T WORK 12 20 d.mul( ); a = 12 d.show_a( ); WON’T WORK b = 20 c = 240 d.display( );
Multilevel Inheritance
class test : public student { class student protected: { float sub1; protected: float sub2; int roll_number; public: public: void get_marks(float, float ); void get_number(int); void put_marks(void); void put_number(void); }; }; void student::get_number(int a) void test : :get_marks(float x,float y) { roll_number = a ; { sub1 = x ; sub2= y ; } } void student : : put_number( ) { cout<<“Roll Number : “<
void test : : put_marks ( ) {cout<<“Marks in SUB1=“<<sub1<<“\n”; cout<<“Marks in SUB2=“<<sub2<<“\n”; }
class result : public test {float total;//private by defaullt public: void display(void); }; void result : : display(void) { total = sub1 + sub2; put_number( ); put_marks( ); cout<<“Total = “<
void main( ) {result student1; student1.get_number(111); student1.get_marks(75.0,59.5);
student1.display( ); } Output:Roll Number: 111 Marks in SUB1 = 75 Marks in SUB2 = 59.5 Total = 134.5
Multiple Inheritance:class M {protected: int m; public: void get_m(int); }; class N { protected: int n; public: void get_n(int); };
class P : public M , pubic N { public: void display(void); }; void M : : get_m(int x) { m=x;} void N : : get_n(int y) { n= y;} void P : : display(void) { cout<<“m = “<<m<<“\n”; cout<<“n = “<
void main( ) { P p; p.get_m(10); p.get_n(20); p.display( ); } Output:m = 10 n = 20 m*n = 200
Resolving Ambiguity in Single Inheritance:class A { public: void display ( ) { cout << “A \n”; } }; class B : public A { public: void display( ) { cout << “B \n” ; } };
void main( ) { B b; //invokes display( ) in B b.display( ); //invokes display( ) in A b . A : : display( ); //invokes display( ) in B b. B : : display( ). } Output:B A B
// HYBRID INHERITANCE class student { protected: int roll_number; public: void get_number(int a ) { roll_number = a ; } void put_number(void) {cout<<“Roll No:”<
public : void get_marks(float x , float y) {part1 = x ; part2 = y; } void put_marks(void) {cout<<“Marks obtained:”<<“\n”; cout<<“Part1 = “<<part1<<“\n”; cout<<“Part2= “ <<part2<<“\n”; } }; class sports { protected: float score ;
public : void get_score(float s) {score = s ; } void put_score(void) {cout<<“Sports wt :”<<score<<“\n”; } }; class result : public test, public sports { float total ; public: void display(void); };
void result : : display(void) {total = part1+part2+score; put_number( ) ; put_marks( ); put_score( ); cout<<“Total Score:”<
Output:Roll No: 1 Marks Obtained : Part1:27.5 Part2:33 Sports wt : 6 Total Score:66.5
Constructors in derived class:# include class alpha { int x; public: alpha( int i) { x=i; cout<<“alpha initialized \n”; } void show_x(void) { cout<<“x = “<<x<<“\n”; } };
class beta { float y ; public: beta( float j ) { y=j; cout<<“beta initialized”; } void show_y(void) { cout<<“y = “<
};
class gamma : public beta, public alpha { int m ,n ; public: gamma( int a , float b , int c int d ) : alpha (a) , beta(b) { m = c; n = d; cout<<“gamma initialized \n “; }
void show_mn(void) { cout<<“m = “<<m<<“\n”; <<“ n = “<
Output:beta initialized alpha initialized gamma initialized x=5 y = 10.75 m = 20 n = 30 /* C++ supports another method of initializing class objects. This method uses what is called initialization list in the constructor function.
constructor(arglist) : initialization section { assignment-section }
INITIALIZATION LIST IN CONSTRUCTORS # include class alpha { int x; public: alpha( int i) { x=i; cout<<“alpha initialized \n”; } void show_x(void) { cout<<“x = “<<x<<“\n”; } };
class beta { float p , q ; public : beta (float a, float b) : p(a) , q(b+p) { cout<<“\n beta constructed”; } void show_beta(void) { cout<<“ p = “<
class gamma :public beta , public alpha {int u , v ; public : gamma(int a , int b, float c) : alpha(a*2),beta(c , c) ,u(a) {v = b; cout<
void main( ) { gamma g(2, 4 , 2.5); cout<<“\n\n Display member values “; g.show_alpha( ); g.show_beta( ); g.show_gamma( ); }
Output:beta constructed alpha constructed gamma constructed Display member values x =4 p = 2.5 q =5 u =2 v =4
/* The argument list in the derived constructor gamma contains only three parameters a, b and c which are used to initialize five data members contained in all the three classes.*/
void main( ) {item x; cout<<“\nobject x “<<“\n”; x.getdata(100,290.5); x. putdata( ); item y; cout<<“\n object y”<<“\n”; y.getdata(200,220.78); y.putdata( ); } object x number:100 cost: 290.5 object y number : 200 cost : 220.78
Nesting of Member Functions
#include
void set :: input(void) { cout<<“Input values of m and n”<<“\n”; cin>>m>>n; } void set:: display(void) { out<<“Largest value=“<
//STATIC CLASS MEMBER #include
{ static int count; int number;. public: void getdata(int a) {number=a; count++; } void getcount(void) { cout<<“count:”; cout<
int item :: count;
void main() { item a, b, c; a.getcount(); b.getcount(); c.getcount(); a.getdata(100); b.getdata(200) c.getdata(300) cout<<“After reading data”<<“\n”; a.getcount(); b.getcount(); c.getcount(); }
Output Screen: count:0 count:0 count:0 After reading data count:3 count:3 count:3
Static Data Members It is initialized to zero when the first object of its class is created. No other initialization is permitted. Only one copy of that member is created for the entire class and is shared by all the object of that class, No matter how many object are created. It is visible only within the class, but its lifetime is the entire program.
#include
void main() { test t1,t2; t1.setcode(); t2.setcode(); test :: showcount(); test t3; t3.setcode(); test t3; t3.setcode(); test :: showcount(); t1.showcode(); t2.showcode(); t3.showcode(); }
Output of theprogram:count:2 count:3 object number:1 object number:2 object number:3
Static Member Functions A static member functions can have access to only other static members( functions or variables) declared within the same class. A static member function can be called using the class name( instead of its objects) as follows class-name :: function-name;
#include
void main() { employee manager[size]; for(int i=0,i<size;i++) { cout<<“Details of Manager”<
Output Details of Manager 1 Enter name:XXX Enter age:45 Details of Manager 2 Enter name:YYY Enter age:35 Manager 1 Name: XXX Age: 45 Manager 2 Name: YYY Age: 35
//Passing Objects as Coordinates #include
void main() { time T1,T2,T3; T1.gettime(4,45); T2.gettime(3,30); T3.sum(T1,T2); cout<<“T1 = “; T1.puttime( ); cout<<“T2 = “; T2.puttime( );. cout<<“T3 = “; T3.puttime( ); }
Output: T1 = 4 hours 45 minutes T2 = 3 hours 30 minutes T3 = 8 hours 15 minutes
Friendly Functions A friend function possesses certain special characteristics: It is not in the scope of the class to which it is declared as friend. Since it is not in the scope of the class it cannot be called using the object of that class. It can be invoked like a normal function without the help of any object. Unlike member functions, it cannot access the member names directly and has to use an object name and dot membership operator with each member name It can be declared either in the public or private part of a class without affecting its meaning. Usually, it has objects as arguments.
class sample { int a; int b; public: void setvalue( ){a=25;b=40;} friend float mean(sample s); }; float mean( sample s) { return(s.a+s.b)/2; }
void main() { sample X; X.setvalue(); cout<<Mean Value=“<<mean(X)<<endl; } Output: Mean value=32.5
The constructor function has the following characteristics:They should be declared in the public section. They are invoked automatically when the objects are created. They do not have return types not even void and therefore they cannot return values. They cannot be inherited though a derived class can call the base class constructor. Like any C++ function they can have default arguments. Constructors cannot be virtual. We cannot refer to their addresses. An object with a constructor (or destructor) cannot be used as a member of the union. They make “ implicit calls” to the operators new and delete when memory allocation is required.
#include
void show( complex c) {cout<
Output: A=2.7+j3.5 B=1.6+j1.6 C=4.3+j5.1 P=2.5+j3.9 Q=1.6+j2.5 R=4.1+j6.4
Copy Constructor It is used to declare and initialize an object from another object A reference variable is used as an argument to the copy constructor. We cannot pass the argument by value to the copy constructor When no copy constructor is defined compiler calls its own copy constructor. The process of initializing through a copy constructor is called copy initialization.
# include
void main() { code A(100); code B(A); code C = A; code D; D=A; cout<<“\n id of A : cout<<“\n id of B : cout<<“\n id of C : cout<<“\n id of D : } Output:id of A : 100 id of B : 100 id of C : 100 id of D : 100
” ; A.display( ) ; ” ; B.display( ) ; ” ;C.display( ) ; ” ;D.display( ) ;
Destructor:A destructor as the name implies is used to destroy the objects that have been created by a constructor. A destructor never takes any argument nor does it return any value It will be invoked implicitly by the compiler upon exit from the program(or block or function as the case may be) to clean up storage that is not accessible. It is a good practice to declare destructors in a program as it releases memory for future use.
# include
void main( ) { cout<<“\n \n Enter Main\n”; alpha A1, A2 , A3 , A4 ; { cout<<“ Enter BLOCK1”; alpha A5; } {cout<<“\n Enter BLOCK2”; alpha A6; } cout<<“\n Re-enter Main”; }
Output:ENTER MAIN. SNo .of object created 1 SNo .of object created 2 SNo .of object created 3 SNo .of object created 4 Enter BLOCK1 SNo .of object created 5 SNo .of object destroyed 5 Enter BLOCK2 SNo .of object created 5 SNo .of object destroyed 5 Re-enter Main SNo .of object destroyed 4 SNo .of object destroyed 3 SNo .of object destroyed 2 SNo .of object destroyed 1
# include
void exchange(class1 & x , class2 & y ) { int temp = x.value1; x.value1= y.value2; y.value2 =temp; } void main( ) {class_1 C1; class_2 C2; C1.indata(100); C2.indata(200); cout<<“Values before exchange”<<“\n”; C1.display( ); C2.display( ); exchange(C1 , C2);
C1.display( ); C2.display( );
} Output:Values before exchange: 100 200 Values after exchange 200 100
Assignment:Programs 5.1 to 5.6(Debugging exercises do in the assignment copy) Program 5.1 5.2,5.5,6.2 and 6.3(Programming exercises take printout of programs and output)
Defrencing Operators:# incude
void main( ) { M n; void ( M : : * pf)(int,int)=&M : :setxy; (n.*pf) ( 10 , 20); cout<<“SUM=“<<sum(n)<<“\n”; M * op = &n; (op->*pf)( 30, 40); cout<<“SUM=“<<sum(n)<<“\n”; } Output:sum = 30 sum = 70
Constructors They should be declared in public section. They are invoked automatically when the objects are created. They do not have return types, not even void and therefore, they cannot return any values. They cannot be inherited , though a derived class can call the base class constructor. Like any C++ functions , they can have default arguments. Constructors cannot be virtual. We cannot refer to addresses. An object with a constructor ( or destructor ) cannot be used as a member of union. They make ‘implicit calls’ to the operators new and delete when memory allocation is required. When a constructor is declared for a class ,initialization of the class objects become mandatory
Overloaded Constructors #include
complex sum (complex c1 , complex c2) { complex c3; c3.x=c1.x+c2.x; c3.y=c1.y+c2.y; return (c3); } void show( complex c) { cout<
void main( ) {complex A ( 2.5, 3.5); complex B(1. 5 ); complex C; C = sum (A , B); cout <<“A = “ ;show( A ) ; cout<<endl; cout <<“B = “ ;show( B ) ; cout<<endl; cout <<“C = “ ;show( C ) ; complex P,Q,R ; P=complex(2.5,3.0); Q=complex(1.5,2.0); R=sum( P, Q); cout<<“\n”;
cout<<“\n”; cout<<“ P = “;show (P); cout<<endl; cout<<“ Q = “;show (Q); cout<<endl; cout<<“ R = “;show (R); cout<<endl; } Output:A = 2.5+j3.5 B = 1.5+j1.5 C= 4.0+j 5.0 P=2.5+j3.0 ; Q=1.5+j2.0 ; R=4.0+j5.0
Operator Overloading It allows to attach additional meaning to operators. The general form of an operator function is:return_type class_name: : operator symbol(argument list) { // task defined } The function operator op( ) is alwaus written in the public part of the class.It may be either a member function or a friend function
Overloading Unary Minus
void space : :getdata(int a,int b,int c) {x=a; # include
void main( ) {space S; S.getdata(10,-20,40); cout << “S : “; S.display(); - S ; // activates operator- () function or S cout<< “ S : “; S.display( ) ; } Output:S : 10 -20 40 S : -10 20 -40
Overloading Binary + operator #include
complex complex : : operator + ( complex c); {complex temp; temp . x= x + c. x; temp . y= y + c .y; return (temp); } void complex : : display(void) { cout<<x<< “ + j” <
void main ( ) { complex C1 , C2 ,C3; C1 = complex(2.5 , 1.5); C2 = complex(1.5 , 2.5); C3=C1+C2; cout<< “C1 = “; C1.display( ) ; cout<< “C2 = “; C2.display( ) ; cout<< “C3 = “; C3.display( ) ; } Output : C1 = 2.5 + j1.5 C2= 1.5 + j2.5 C3= 4.0 + j4.0
Rules for Overloading Operators:1. Only existing operators can be overloaded.New
operators cannot be created. 2. The overloaded operator must have atleast one operand. 3. We cannot change the basic meaning of an operator.That is to say that we cannot redefine the (+) operator to substract one value from the other. 4. Overloaded operators follow the syntax rules of original operators.They cannot be overridden. 5. There are some operators that cannot be overloaded. 6. We cannot use friend functions to overload certain operators. However ,member functions can be used to overload them.
Operators that cant be overloaded Sizeof Size of operator . Membership operator .* Point-to-member operator :: Scope resolution operator ?: Conditional operator Where a friend cannot be used = Assignment operator () Function call operator [] Subscripting operator -> Class member access operator
7. Unary operators overloaded by means of a member function take no explicit arguments and return no explicit values, but those overloaded by means of a friend function ,take one reference argument (the object of the relevant class).
8. Binary operators overloaded through a member function take one explicit argument and those which are overloaded through a friend function take two explicit arguments. 9. When using binary operators overloaded through a member function the left hand operand must be an object of the relevant class. 10.Binary arithmetic operators such as + , - , * , / must explicitly return a value.They must not attempt to change their own arguments.
Type Conversions // Basic to Class Type class Time { int hrs, mins; public: …………………. time( int t) {/* The constructors used for type conversion take a single argument whose type is to be converted.*/ hrs = t / 60; mins = t% 60; } }; time T1; int duration = 85; T1=duration;
//Class to Basic Type vector : : operator double( ) //Casting Operator Function {double sum = 0; for( int i = 0 ; i < size ; ++i) { sum = sum +v[ i ] * v [i ] ; } return sqrt(sum); } double length = double(V1); or double length = V1; Here V1 is an object of type vector The casting operator function should satisfy following conditions:It must be a class member. It must not specify a return type. It must not have any arguments.
One Class to Another Class Type # include
void putdata( ) {cout<<“Code : “<
class invent2 { int code; float value; public : invent2( ) {code = 0; value = 0; } invent2( int x ,float y ) {code = x; value = y; } void putdata( ) {cout<<“Code:”<
invent2(invent1 p) {//constructor for conversion code = p . getcode( ); value = p.getitems( ) * p.getprice( ); } };// End of destination class void main ( ) { invent1 s1(100,5,140.0 ); invent2 d1; float total _value; //invent1 To float total_value = s1; /* invent1 To invent2*/ d1 = s1; cout<<“Product details – invent1 type”<<“\n”; s1.putdata () ;
cout<<“Product details-invent2 type”<<“\n”; d1. putdata( ) ; } Output:Product details-invent1 type Code: 100 Items: 5 Value: 140 Stock value value = 700 Product details – invent2 type Code: 100 Value: 700
void main( ) Object Pointers { item abc; class item item *ptr = &abc; { int cd; /* ptr is a pointer object of float cost; item class that is initialized public: with the address of another void getdata( int x , float y) object abc.*/ { cd = x; abc.getdata(26 , 150.50); cost = y; abc .show( ); } Or void show(void) ptr->.getdata(26 , 150.50); {cout<<“Code:”<
Output:Code:26 Cost: 150.50 Code:26 Cost: 150.50 Code:26 Cost: 150.50
# include
while (y< = t) {sum = sum + sum *r; y = y + 1; } return sum ; }/*Default arguments are useful when some argumets always have the same value .We must add defaults from right to left We cannot provide a default value in the middle of argument list.
Inheritance : Extending Classes Reusability is yet another feature of OOP. It is always nice if we could reuse something that already exist rather than trying to create the same all over again. It will not only save time and money but also reduce frustration and increase reliability Once a class has been written and tested ,it can be adopted by other programmers to suit their requirements.
This is basically done by creating new classes, reusing the properties of existing ones. The mechanism of deriving a new class from an old one is called inheritance (or derivation). The old class is referred to as the base class and the new one is called derived class or subclass.
Single Inheritance:A derived class with only one base class
A
B
Multiple Inheritance:A derived class with several base classes.
B
A
C
Hierarchical Inheritance:The traits of one class may be inherited by more than one class
A
B
C
D
Multilevel Inheritance:The mechanism of deriving a class from another ‘derived class’. A
B
C
The general form of deriving a derived class is:class derived-class-name : visibility-mode base-class-name { ……….// ............// members of derived class }; class ABC: private XYZ {members of ABC }; class ABC :public XYZ {members of ABC }; class ABC : XYZ {members of ABC };
Single Inheritance :PUBLIC # include
public:void mul(void); void display ( ); }; void B : :get_ab(void) {a = 5 ; b = 20 ; } int B : : get_a ( ) { return a ; } void B : : show_A ( ) {cout < <“A = “<
void D : : display( ) {cout<<“a = “<
d . b = 20; d.mul( ); d.display( ); } Output:a=5 a=5 b = 10 c = 50 a=5 b = 20 c = 100
void display(void); # include
void D : : display ( ) { show_a( ); cout<<“b = “<
// d . b = 20; d . mul( ); d.display( ); } Output:Enter values of a and b:
5 10 a=5 void main ( ) b = 10 { c = 50 D d; Enter values of a and b: // d. get_ab( ); WON’T WORK 12 20 d.mul( ); a = 12 d.show_a( ); WON’T WORK b = 20 c = 240 d.display( );
Multilevel Inheritance
class test : public student { class student protected: { float sub1; protected: float sub2; int roll_number; public: public: void get_marks(float, float ); void get_number(int); void put_marks(void); void put_number(void); }; }; void student::get_number(int a) void test : :get_marks(float x,float y) { roll_number = a ; { sub1 = x ; sub2= y ; } } void student : : put_number( ) { cout<<“Roll Number : “<
void test : : put_marks ( ) {cout<<“Marks in SUB1=“<<sub1<<“\n”; cout<<“Marks in SUB2=“<<sub2<<“\n”; }
class result : public test {float total;//private by defaullt public: void display(void); }; void result : : display(void) { total = sub1 + sub2; put_number( ); put_marks( ); cout<<“Total = “<
void main( ) {result student1; student1.get_number(111); student1.get_marks(75.0,59.5);
student1.display( ); } Output:Roll Number: 111 Marks in SUB1 = 75 Marks in SUB2 = 59.5 Total = 134.5
Multiple Inheritance:class M {protected: int m; public: void get_m(int); }; class N { protected: int n; public: void get_n(int); };
class P : public M , pubic N { public: void display(void); }; void M : : get_m(int x) { m=x;} void N : : get_n(int y) { n= y;} void P : : display(void) { cout<<“m = “<<m<<“\n”; cout<<“n = “<
void main( ) { P p; p.get_m(10); p.get_n(20); p.display( ); } Output:m = 10 n = 20 m*n = 200
Resolving Ambiguity in Single Inheritance:class A { public: void display ( ) { cout << “A \n”; } }; class B : public A { public: void display( ) { cout << “B \n” ; } };
void main( ) { B b; //invokes display( ) in B b.display( ); //invokes display( ) in A b . A : : display( ); //invokes display( ) in B b. B : : display( ). } Output:B A B
// HYBRID INHERITANCE class student { protected: int roll_number; public: void get_number(int a ) { roll_number = a ; } void put_number(void) {cout<<“Roll No:”<
public : void get_marks(float x , float y) {part1 = x ; part2 = y; } void put_marks(void) {cout<<“Marks obtained:”<<“\n”; cout<<“Part1 = “<<part1<<“\n”; cout<<“Part2= “ <<part2<<“\n”; } }; class sports { protected: float score ;
public : void get_score(float s) {score = s ; } void put_score(void) {cout<<“Sports wt :”<<score<<“\n”; } }; class result : public test, public sports { float total ; public: void display(void); };
void result : : display(void) {total = part1+part2+score; put_number( ) ; put_marks( ); put_score( ); cout<<“Total Score:”<
Output:Roll No: 1 Marks Obtained : Part1:27.5 Part2:33 Sports wt : 6 Total Score:66.5
Constructors in derived class:# include
class beta { float y ; public: beta( float j ) { y=j; cout<<“beta initialized”; } void show_y(void) { cout<<“y = “<
};
class gamma : public beta, public alpha { int m ,n ; public: gamma( int a , float b , int c int d ) : alpha (a) , beta(b) { m = c; n = d; cout<<“gamma initialized \n “; }
void show_mn(void) { cout<<“m = “<<m<<“\n”; <<“ n = “<
Output:beta initialized alpha initialized gamma initialized x=5 y = 10.75 m = 20 n = 30 /* C++ supports another method of initializing class objects. This method uses what is called initialization list in the constructor function.
constructor(arglist) : initialization section { assignment-section }
INITIALIZATION LIST IN CONSTRUCTORS # include
class beta { float p , q ; public : beta (float a, float b) : p(a) , q(b+p) { cout<<“\n beta constructed”; } void show_beta(void) { cout<<“ p = “<
class gamma :public beta , public alpha {int u , v ; public : gamma(int a , int b, float c) : alpha(a*2),beta(c , c) ,u(a) {v = b; cout<
void main( ) { gamma g(2, 4 , 2.5); cout<<“\n\n Display member values “; g.show_alpha( ); g.show_beta( ); g.show_gamma( ); }
Output:beta constructed alpha constructed gamma constructed Display member values x =4 p = 2.5 q =5 u =2 v =4
/* The argument list in the derived constructor gamma contains only three parameters a, b and c which are used to initialize five data members contained in all the three classes.*/
Related Documents
C-c++
November 2019 73
C C
December 2019 93
C,c++
November 2019 69
C#
November 2019 20
C#
November 2019 10
