C++C++

Dr. Binu P ChackoAssociate Professor

Department of Computer ScienceDepartment of Computer SciencePrajyoti Niketan College, Pudukkad, THRISSUR

FundamentalsFundamentals • OOP language developed by Bjarne Stroustrup at AT & T Bell 

L b t i i l 1980’Laboratories in early 1980’s• Features: classes, inheritance, function overloading, operator 

overloading• Bottom up object oriented design• Bottom‐up object‐oriented design• Comments: // or /*….*/• #include<iostream> ‐ for I/O statements

t<<“i ti ( t t ) t ”• cout<<“insertion (put to) operator”;int main(){ float n1, n2, avg;

“E b “cout<<“Enter two numbers : “;cin>>n1>>n2;avg = (n1 + n2 ) / 2;

\cout<<“\nAverage : “<<avg;return 0; }

Cont…Cont…#include<iostream.h>class student{ private:

Include filesClass declaration

{ private:char name[10];int age;

public:public:void read(){  cout<<“Enter name, age”;

cin>>name>>age; }

Member function definition

cin>>name>>age; }void disp(){ cout<<“Name : “<<name;

cout<<“Age : “<<age; }};cout<< Age     :  <<age; }};main(){  student s;

d()

Main function

s.read();s.disp(); }

TokensTokens 

• Smallest individual units in a programSmallest individual units in a program• Keywords

asm defa lt float operator s itchasmautoboolbreak

defaultdeletedodouble

floatforfriendgoto

operatorprivateprotectedpublic

switchtemplatethisthrow

casecatchcharclass

dynamic_castelseenumexplicit

ifinlineintlong

registerreinterpret_castreturnshort

truetrytypedeftypeidclass

constconst_castcontinue

explicitexportexternfalse

longmutablenamespacenew

shortsignedsizeofstatic

typeidtypenameunionunsigned

voidvolatile

wchar_twhile

static_caststruct

usingvirtual

Cont…Cont…

• Identifiers: names of variables, ,functions, arrays, classes, etc.

• No limit on the length of the << Insertion operator

>> Extraction operator

:: Scope resolution operatorname• Constants: wchar_t (wild character) type used for

:: Scope resolution operator

::* Pointer to member declarator

‐>* Pointer to member operatorcharacter) type used for character sets that cannot fit a character into a single byte. E g L’ab’

.* Pointer to member operator

delete Memory release operator

endl Line feed operatorE.g. L’ab’• Strings• Operators

p

new Memory allocation operator

setw Filed width operator

• Operators

Data TypesData Types• Basic data types: char, int, float, double• long, short, signed, unsigned• User defined data types: structures, classes, enumerated data type• Derived data type: arrays, functions, pointers• Symbolic constants: created using const and enum• Reference variable provides an alias (alternative name) for a 

previously defined variablefloat total = 100;float & sum = total; reference to floatchar & a = ‘\n’;int & n = 50; main()

{ i t 10 void f(int & x)int *p;int & m = *p;• A reference variable must be initialized at the time of declaration

{   int m = 10;f(m); }

void f(int & x){   x += 10;    }

• If value of one variable is updated, it will also reflect in its alias

OperatorsOperators • Scope resolution operator (::)int m = 10;main()main(){ int m = 20;

cout<<m;cout<< m global variable }cout<<::m; global variable }

• Memory management operators (new, delete)int *p = new int;fl t *f fl t(12 3)float *f = new float(12.3);char *c = new char[10];delete p;d l []delete []c;• Manipulatorscout<<m<<endl<<n;cout<<setw(5)<<sum;• Type cast operator: avg = sum / float(n);

• Operator overloading: *, <<, >>• Operators that cannot be overloaded: ?:, ::, ., sizeof, .*

Cont…Operator precedence and associativity

::‐> . () [] postfix ++ postfix ‐‐

f f !

L – RL – R

Prefix ++ prefix ‐‐ ~ ! Unary + unary –unary * unary & (type) sizeof new delete‐> * *•/ %

R – LL – RL – R/

+ ‐<< >><< = >> =

!

L – RL – RL – RL R== !=

&^|

L – RL – RL – RL – R

&&||?:= *= /= %= += =

L – RL – RL – RR L=  = /= %= += ‐=

<<== >>== &= ^= |=,

R – LL ‐ R

Expressions• Constant expression consists of only constant values12 + 5 / 2 512 + 5 / 2.5• Integral expression produces integer resultsm + n * 5• Float expressions produce floating point results• Float expressions produce floating point resultsx + y * 3.2• Pointer expressions produce address valuest 3ptr + 3

• Relational expression: x <= y• Logical expression: a < b && c >= d

d l d b l l (• Bitwise expressions are used to manipulate data at bit level (testing and shifting of bits)

x << 2  left shift 2 bit positionY >> 3 i ht hift 3 bit itiY >> 3 right shift 3 bit positionShift operations are used for multiplication and division by powers of 2• Assignment expressionsCh i d i 10 b d i i i li iChained assignment: x = y = 10;  cannot be used in intializationEmbedded assignment: x = (y = 50) + 10;Compound assignment: x += 10;

Implicit ConversionImplicit ConversionRHO Char Short Int Long Float Double Long 

LHO double

CharShortI t

IntIntI t

IntIntI t

IntIntI t

LongLongL

FloatFloatFl t

“““

“““Int

LongFloatDouble

IntLongFloatDouble

IntLongFloatdouble

IntLongFloatdouble

LongLongFloatdouble

FloatFloatFloatdouble

““““

““““

Long double

Long double

Long double

Long double

Long double

Long double

Long double

Long double

CONTROL STRUCTURESSequence structureSelection structure: if, switchLoop structure: do while while forLoop structure: do‐while, while, for

FunctionsFunctions • Return by referenceint & max(int &x, int &y){ if (x > y)

return x;else

return y; }• Function returns reference to x or yFunction call:  max(a, b) = ‐1;• Inline function is expanded in line when it is invokedinline double cube(double a)( ){ return(a * a * a); }Function call:  c =  cube(3.5);• All inline functions must be defined before they are calledy

Cont…Cont…• Default parametersfloat amount(float principal, int period, float rate = 0.15);( p p , p , );value = amount(5000, 7);value = amount(5000, 5, 0.12);• Constant argumentsConstant argumentsint length(const char *p);• Function should not modify the argument

Math library functions

ceil(x) ceil(8.1) = 9.0, ceil(‐8.8) = ‐8.0

cos(x) tan(x)( ) ( )

exp(x) log10(x)

fabs(x) pow(x, y)

fl ( ) fl (8 2) 8 0 fl ( 8 8) 9 0floor(x) floor(8.2) = 8.0, floor(‐8.8) = ‐9.0

sin(x) sqrt(x)

log(x) Natural logarithm of x

Function overloadingFunction overloading#include<iostream.h>

()void main(){ int volume(int);

double volume(double, int);long volume(int int int);long volume(int, int, int);cout<<volume(10)<<endl;cout<<volume(2.5, 8)<<endl;cout<<volume(100 75 15)<<endl; }cout<<volume(100, 75, 15)<<endl; }

int volume(int s) cube{ return(s * s * s); }double volume(double r, int h) cylinder( , ) y{ return(3.14 * r * r * h); }long volume(int l, int b, int h) rectangular box{ return(l * b * h); }

Classes and Objects class itemClasses and Objectsclass item{ private:

{ private:int code;float price;

public:int code;float price;

public:()

public:coid read();void display();  };

void item::read()void read(){ cin>>code>>price; }void display(){ cout<<code<<price; }} x y;

{   cin>>code>>price;   }void item::display(){   cout<<code<<price;  }};item a;{ cout<<code<<price; }} x, y;

item z;x.read(); x.display();• A way to bind data and its associated functions together (encapsulation)

item a;a.read();a.display();

A way to bind data and its associated functions together (encapsulation)• Class declaration describes the type and scope of its members• It allows data (and functions) hiding• define a class – create a new abstract data typeyp• Add inline in the header line of function definition to make it as inline 

funciton

Cont…Cont…• A member function calls another member function• Private member function• Arrays within a class• Memory allocation for objects• Static member variable (class variable): initializes to 0 when the first 

object of its class is created• Shared by all objects of that class• Visible only within the class, but its lifetime is the entire program• Local classes: classes defined and used inside a function• They can access global variables (using ::) and static variables 

d l d i id h f ideclared inside the function• They cannot have static data members• Member functions must be defined inside the class

Cont…Cont…class item{ static int count;

int number;public:

void getdata (int a)void getdata (int a){  number = a;count++; }

void getcount ()void getcount (){  cout<<count<<endl; } };

int item::count; int item::count = 35;void main()(){    item a, b;

a.getcount(); b.getcount();a.getdata(50);      b.getdata(60);a.getcount(); b.getcount(); } 

Static Member FunctionStatic Member Function• Access only the static member variables in the same class• Called using class nameclass test{  static int count;public:public:

void setcode(){  ++count; }static void showcount()static void showcount(){  cout<<count<<endl; } };

int test::count;void main()(){    test t1, t2;

t1.setcode(); t2.setcode();test::showcount(); }

Array of ObjectsArray of Objectsclass employee{   char name[10];

int age;public:

void read()void read(){  cin>>name>>age; }void disp(){ cout<<name<<age; } };{  cout<<name<<age; } };

void main(){   employee manager[5];

int i;;for (i = 0; i < 5; ++i)

manager[i].read();for (i = 0; i < 5; ++i)

manager[i].disp(); }

Add TimeAdd Timeclass time{ int hours;

int minutes;blipublic:void settime(int h, int m){  hours = h; minutes = m; }void disptime() const const member functionp (){  cout<<hours<<minutes;}void addtime(time t1, time t2){   minutes = t1.minutes + t2.minutes;

ho rs min tes / 60hours = minutes / 60;minutes %= 60;hours += t1.hours + t2.hours; } };

void main(){ time tm1, tm2, tm3;

tm1.settime(3, 30); tm2.settime(4, 45);tm3.addtime(tm1, tm2);tm1 disptime(); tm2 disptime(); tm3 disptime(); }tm1.disptime(); tm2.disptime(); tm3.disptime(); }

friend functionfriend functionclass sample{ int a;

int b;public:

void setvalue() { a = 10;  b = 22;  }friend float mean(sample s); }; or declared in private part.

float mean(sample s) Access private member of the{ return((s.a + s.b) / 2.0); } class; Can’t access member void main() directly; Use objects as arguments{ sample X;{ p ;

X.setvalue();cout<<mean(X); } Can’t be called using object

• A function can be declared as a friend in any number of classesy

Cont…Cont…• Member function of one class can be friend function of another classclass X{  ……….

int fun1();};………. };

class Y{ ……….

friend int X::fun1();friend int X::fun1();………. };

• All member functions of one class (X) can be friend functions of another class (Z)

class Z{ ………

friend class X;}……… };

Cont…Cont…

class ABC; forward declaration;class XYZ{ int x;public:

void max(XYZ m, ABC n){ if (m.x >= n.a)

cout<<m.x;public:void setvalue(int i) { x = i; }friend void max(XYZ, ABC); };

elsecout<<n.a; }

void main(){ ABC abc;

class ABC{ int a;public:

{ ABC abc;abc.setvalue(100);XYZ xyz;xyz.setvalue(200);public:

void setvalue(int i) { a = i; }friend void max(XYZ, ABC); };

max(xyz, abc); }

Cont…Cont…class class_2; Call by referenceclass class_1{ int value1;public:

void exchange(class_1 & x,class_2 & y)

{   int temp = x.value1;x value1 = y value2;void indata(int a) { value1 = a; }

void display() { cout<<value1; }friend void exchange(class_1 &, class_2 &);};

x.value1 = y.value2;y.value2 = temp; }

void main(){   class_1 c1;

class class_2{ int value2;public:

class_2 c2;c1.indata(10); c2.indata(20);c1.display(); c2.display();exchange(c1 c2);

void indata(int a) { value2 = a;  }void display() { cout<<value2; }friend void exchange(class_1 &, class_2 &);};

exchange(c1, c2);c1.display(); c2.display();   }

g ( _ , _ );};

return objectclass complex{ float x; return object{ ;

float y;public:

void input(float real, float img){ x = real;  y = img; }void show(complex c){ cout<<c.x<<“ + i”<<c.y; }f i d l ( l l ) }friend complex sum(complex, complex); };

complex sum(complex c1, complex c2){    complex c3;

c3 x = c1 x + c2 x;c3.x = c1.x + c2.x;c3.y = c1.y + c2.y;return(c3); }

void main()void main(){ complex A, B, C;

A.input(4.5, 6.2); B.input(3.3, 9.1);C = sum(A, B);( , )A.show(A); B.show(B); C.show(C); }

Pointer to memberPointer to memberclass M

void main(){ int x;int y;

public:

void main(){  M n;

Pointer to member functionvoid (M :: *pf)(int, int) = &M :: set_xy;

void set_xy(int a, int b){ x = a; y = b; }friend int sum(M); };

(n.*pf)(5, 35);cout<<sum(n);M *op = &n;(op‐>*pf)(23 74);

int sum(M m){ int M ::* px = &M :: x;

int M ::* py = &M :: y; Pointer to member variable

(op‐> pf)(23, 74);cout<<sum(n); }

py y;M *pm = &m; Pointer to objectint s = m.*px + pm‐>*py;return(s); }( ); }

ConstructorConstructor • A member function with same name of the class. • Invoked when an object is created; initializes the objectclass integer{ int m, n;public:

()integer(){ m = 0; n = 0; } };

integer int1;• Should be declared under public• Should be declared under public• No return type• Cannot be inherited, virtual, refer its address• Make implicit calls to the operators new and delete when memoryMake implicit calls to the operators new and delete when memory 

allocation is required• An object with a constructor or destructor cannot be used as a member of 

a unionf l I h b f h• Default constructor: no parameters. In the absence of such a constructor, 

compiler will supply a default constructor

Parameterized ConstructorParameterized Constructor• Constructors with argumentsl i tclass integer{  int m, n;public:

integer(int x, int y)g ( , y){ m = x;  n = y; }void display(){  cout<<m<<n; } };

void main()void main(){  integer int1 = integer(100, 0); explicit call

integer int2(10, 40); implicit callint1.display(); int2.display(); }

class A{  ……….public:

A (A); };

class A{  ……….public:

If no copy constructor, compiler suppliesits own copy constructorA (A); };

illegal A (A&); };Copy constructor

its own copy constructor

Overloaded ConstructorOverloaded Constructorclass integer{  int m, n;public:public:

integer(){ m = 0;  n = 0; }integer(int a, int b){ b }{ m = a;  n = b; }integer(integer & i){ m = i.m;  n = i.n; } };

integer i1;g ;integer i2(34, 94);integer i3(i2); or  i3 = i2;Integer i6;i6 i1; doesn’t invoke copy constructor; member by member copyi6 = i1; doesn t invoke copy constructor; member‐by‐member copyConstructor with default argumentsinteger(int a, int b = 0){  m = a;  n = b; }integer i4(45); integer i5(12, 19);

Dynamic initialization of constructorsDynamic initialization of constructors

class fixed_deposit void main(){ fixed deposit fd1 fd2 fd3;{   int p, y;

float rate;public:

fixed deposit() {}

{ fixed_deposit fd1, fd2, fd3;int x, y, z;float w;cin>>x>>y>>z;

fixed_deposit() {}fixed_deposit(int a, int b, float c = 0.11){  p = a; y = b; rate = c; }fixed deposit(int a int b int c)

fd1 = fixed_deposit(x, y, z);cin>>w>>x>>y;fd2 = fixed_deposit(x, y, w);cin>>x>>y;fixed_deposit(int a, int b, int c)

{  p = a, y = b; rate = c; }void display(){  cout<<p<<y<<rate; } };

cin>>x>>y;fd3 = fixed_deposit(x, y);fd1.display();fd2.display();f () }

{ p y ; } };fd3.display(); }

Dynamic ConstructorsDynamic Constructors#include<string.h>class String{ char *name;{  char  name;

int length;public:

String(){ l th 0{  length = 0;name = new char[length + 1]; }

String(char *s){  length = strlen(s);{ g ( );name = new char[length + 1];strcpy(name, s); }

void display(){ cout<<name; } };{  cout<<name; } };

void main(){   char *str = “Robin”;

String s1, s2(str), s3(“Remya”);s2.display(); s3.display(); }

DestructorDestructor • A member function with the same name of the class• Used to destroy the objects created by a constructor• Invoked by the compiler upon exit from the program (or block or function)int count = 0;class alpha{ bl{ public:

alpha(){  cout<<“No of object created”<<++count;}~alpha() No arguments no return value~alpha() No arguments, no return value{ cout<<“No of object destroyed”<<count‐‐;}};

void main(){ alpha a1 a2 a3;{   alpha a1, a2, a3;

{   alpha a4; }{   alpha a5; } }

• Objects are destroyed in the reverse order of creationj y

Operator OverloadingOperator Overloading• Giving special meaning to an existing operator• Power of extensibility – original meaning is not lost• Semantics of an operator can be extended, bit not the syntax. i.e., number of 

operands precedence and associativity of operators remain the sameoperands, precedence and associativity of operators remain the sameOverloading unary operatorclass unary{ int x;

int y;public:

void read(){ cin>>x>>y; }{ cin>>x>>y; }void display(){ cout<<x<<y; }void operator‐() operator function

Using friend functionDeclarationfriend void operator‐(unary &m);D fi iti{   x = ‐x;   y = ‐y; }};

void main(){ unary um;

um.read(); um.display();

Definitionvoid operator‐(unary &m){   m.x = ‐m.x;    m.y = ‐m.y;    }

um.read();    um.display();‐um;um.display(); }

Binary OperatorBinary Operatorclass complex{ int x;

int y;public:

complex() {}complex() {}complex(int real, int img){ x = real; y = img; }complex operator+(complex c)complex operator+(complex c){ return(complex((x + c.x), (y + c.y)));

complex t;t.x = x + c.x; t.y = y + c.y;

void main(){   complex c1(12, 5), c2(3, 4), c3;

3 1 2; y y y;

return(t); }void display(){ cout<<x<<“ + i“<<y; }};

c3 = c1 + c2;c3 = c1.operator+(c2);c3.display(); }

Using friend FunctionsUsing friend Functionsclass vector{ int v[5];public:

vector(){ for(int i 0; i < 5; ++i){  for(int i = 0; i < 5; ++i)

v[i] = 0; }vector(int *x){ for(int i = 0; i < 5; ++i){  for(int i = 0; i < 5; ++i)

v[i] = x[i]; }Cannot overload =, (), [] and ‐> using friend function

friend vector operator *(int a, vector b);p ( , );friend vector operator *(vector b, int a);friend istream & operator >> (istream &, vector &);friend ostream & operator << (ostream &, vector &); };

Cont…Cont…vector operator * (int a, vector b){ vector c;

for(int i = 0; i < 5; ++i)[i] * b [i]

int x[5] = {23, 41, 5, 90, ‐3};void main(){ vector m;c.v[i] = a * b.v[i];

return(c); }vector operator * (vector b, int a){ vector c;

{   vector m;vector n = x;cin>>m;cout<<m;{ ;

for(int i = 0; i < 5; ++i)c.v[i] = b.v[i] * a;

return(c); }istream & operator >> (istream &din e tor &b)

vector p, q;p = 2 * m;q = n * 3;cout<<p;istream & operator >> (istream &din, vector &b)

{ for(int i = 0; i < 5; ++i)din>>b.v[i];

return(din); }

cout<<p;cout<<q; }

Overloaded operator must have at least one operand of user‐defined typeostream & operator << (ostream &dout, vector &b){ for(int i = 0; i < 5; ++i)

dout<<b v[i];dout<<b.v[i];return(dout); }

String Manipulationstring operator + (string s){   string t;t.len = len + s.len;t p new char[t len + 1]String Manipulation

class string{ h *

t.p = new char[t.len + 1];strcpy(t.p, p);strcat(t.p, s.p);return(t); }

{ char *p;int len;

public:string()

int operator <= (string s){   int m = strlen(p);int n = strlen(s.p);if (m <= n)g()

{    len = 0;  p = 0; }string(const char *str){ len = strlen(str);

p = new char[len + 1];

if (m <= n)return(1);

elsereturn(0); }

p = new char[len + 1];strcpy(p, str); }

string(const string & s){ len = s.len;

void show(){    puts(p); }};void main(){ string s1 = “Computer “ s2 = “Science”;

p = new char[len + 1];strcpy(p, s.p); }

~string(){ delete p; }

{  string s1    Computer  , s2    Science ;string t1, t2, t3;t1 = s1; t2 = s2;t3 = t1 + t2;

h () 2 h () 3 h (){ delete p; } t1.show();  t2.show();  t3.show();if (t1 <= t2)  cout<<“Smaller”;else cout<<“Larger”; }

Type ConversionType Conversion• Basic to Class typeUsing constructor• Class to Basic typevector::operator int() No parameters and return type{ int sum = 0;

for(int i = 0; i < 5; ++i)sum += v[i];

return(sum); }• operator int() can be used asint s = int(v1); or int s = v1;( ); ;• One class to another class typeConversion using a casting operator in source class or a constructor in 

destination class

Exampleclass invent2class invent1{ int code; Example{ ;

int items;float price;

public:i t1(i t i t b fl t )

class invent2{  int code;float value;

invent1(int a, int b, float c){ code = a;  items = b;  price = c;}void display(){ cout<<code<<items<<price; }

public:invent2(){  code = 0; value = 0; }invent2(invent1 p)

int getcode(){  return(code); }int getitems(){ return(items);}

invent2(invent1 p){  code = p.getcode();value = p.getitems() * p.getprice();}void display()

{  return(items);}float getprice(){  return(price); }operator float()

{  cout<<code<<value; } };void main(){  invent1 s1(23, 5, 6.5);invent2 d1;

{  return(items * price); }operator invent2()   invent1 to invent2{  invent2 t;t code = code;

invent2 d1;float total_value;total_value = s1;d1 = s1;1 di l ()t.code = code;

t.value = price * items;return(t); } };

s1.display();cout<<total_value;d1.display(); }

InheritanceInheritance • Deriving a new class (derived class or subclass) from an old one 

(b l ) bilit(base class) – reusability• Derived class inherits some or all of the traits from the base class• Single inheritance: A derived class with one base class

l l h d d l h b l• Multiple inheritance: A derived class with many base classes• Hierarchical inheritance: Traits of one class may be inherited by 

more than one classM ltil l i h it D i i l f th d i d l• Multilevel inheritance: Deriving a class from another derived class

• Hybrid inheritanceclass ABC: private XYZ{ b f ABC }

Public members of the base class are accessible withinderived class but not to the objects of derived class{  members of ABC };

class ABC : public XYZ{  members of ABC };

derived class, but not to the objects of derived class

Public members of the base class are accessible to objects of derived class

• Private members are not inherited

Single InheritanceSingle Inheritanceclass B{ i t{ int a;public:

int b;void get_ab() oid main()g _ (){  a = 23;  b = 90;  }int get_a(){  return(a); }void show a()

void main(){  D d;d.get_ab();d.mult();void show_a()

{  cout<<a; } };class D : public B{ int c;

d.show_a();d.display();d,b = 26;d mult();public:

void mult(){  c = b * get_a(); }void display()

d.mult();d.display(); }

void display(){  cout<<get_a()<<b<<c; }};

Privately Derived classPrivately Derived classclass D : private B{ int c;public:void mult(){ get ab();{     get_ab();

c = b * get_a(); }void display(){ cout<<get a()<<b<<c; }};{  cout<<get_a()<<b<<c; }};

void main(){   D d;

d.mult();();d.display(); }

• If both base class and derived class contain a function with same name, then the derived class function supersedes the base class definition

Multilevel InheritanceMultilevel Inheritanceclass student{ t t d

Access specifiers may appear in any order and any number of times in a class

Members declared under protected section are accessible{ protected:int roll_number;

public:void get_number(int a) class result : pubic test

Members declared under protected section are accessible within the class and in the derived class

g _ ( ){  roll_number = a; }void put_number(){  cout<<roll_number;  }};

class test : public student

p{  float total;public:void display(){ total = sub1 + sub2;class test : public student

{ protected:float sub1;float sub2;

{   total = sub1 + sub2;put_number();put_marks();cout<<total; }};

public:void get_marks(float x, float y){  sub1 = x;  sub2 = y; }void put marks()

void main(){  result student1;student1.get_number(101);student1 get marks(79 61);void put_marks()

{  cout<<sub1<<sub2; }};student1.get_marks(79, 61);student1.display(); }

Multiple InheritanceMultiple Inheritanceclass M{ t t d{ protected:

int m;public:

void get_m(int x) void main()g _ ( ){  m = x; }};

class N{ protected:

int n;

{  P p;p.get_m(34);p.get_n(40);p.display(); }int n;

public:void get_n(int y){  n = y; }};

p.display(); }

class P : public M, public N{ public:

void display(){ cout<<m<<n<<m * n; }};{  cout<<m<<n<<m   n; }};

AmbiguityAmbiguity class M{ bli{ public:

void display(){  cout<<“Class M”; }};

class N

class A{ public:

void display(){ cout<<“A”; }};

{ public:void display(){  cout<<“Class N”; }};

class P : public M public N

{  cout A ; }};class B : public A{ public:

void display(){ t “B” }}class P : public M, public N

{ public:void display(){  M::display(); }}; Solution

{  cout<<“B”; }};void main(){  B b;b.display();

void main(){  P p;p.display(); }

p y()b.A::display();b.B::display(); }

Hybrid Inheritanceclass sports{ protected:

float score;Hybrid Inheritanceclass student{ t t d

float score;public:void get_score(float s){  score = s; }

{ protected:int roll_no;

public:void get_number(int a)

void put_score(){  cout<<score; }};

class result : public test, public sports{ float total;g _ ( )

{  roll_no = a; }void put_number(){  cout<<roll_no; }};

class test : public student

{    float total;public:void display(){ total = part1 + part2 + score;

t b ()class test : public student{ protected:

float part1, part2;public:

put_number();put_marks();put_score();cout<<total; }};

void get_marks(float x, float y){  part1 = x;  part2 = y; }void put_marks(){ cout<<part1<<part2; }};

}}void main(){  result student1;student1.get_number(1380);student1 get marks(83 91);{  cout<<part1<<part2; }}; student1.get_marks(83, 91);student1.get_score(4.6);student1.display(); }

Virtual Base Classclass sports : public virtual student{ protected:

float score;Virtual Base Class float score;public:void get_score(float s){  score = s; }

Duplication of inherited members due to multiple paths can be avoided by making the common base class as virtual base class

class student{ protected:

int roll_no;

void put_score(){  cout<<score; }};

class result : public test, public sports{ float total; One op of st dent ill

common base class as virtual base class

Abstract class

_public:

void get_number(int a){  roll_no = a; }void put number()

{    float total;public:void display(){ total = part1 + part2 + score;

t b ()

One copy of student willbe inherited

void put_number(){  cout<<roll_no; }};

class test : virtual public student{ protected:

put_number();put_marks();put_score();cout<<total; }};

float part1, part2;public:

void get_marks(float x, float y){ part1 = x; part2 = y; }

}}void main(){  result student1;student1.get_number(1380);student1 get marks(83 91);{  part1 = x;  part2 = y; }

void put_marks(){  cout<<part1<<part2; }};

student1.get_marks(83, 91);student1.get_score(4.6);student1.display(); }

Derived class ConstructorDerived class Constructorclass alpha First, constructor beta(b)

is executed{ int x;public:

alpha(int i){ x i; }

class gamma : public beta, public alpha{   int m, n;public:

is executed

{  x = i; }void show_x(){  cout<<x; }};

class beta

public:gamma(int a, float b, int c, int d) :

alpha(a), beta(b){  m = c;  n = d; }id h ()class beta

{ float y;public:

beta(float j)

void show_mn(){  cout<<m<<n; }};

void main(){   gamma g(31, 8.4, 38, 42);( j)

{  y = j; }void show_y(){  cout<<y; }};

{ g g( , , , );g.show_x();g.show_y();g.show_mn(); }

The constructors for virtual base classes are invoked before any non‐virtual base classes

Initialization ListInitialization Listclass alpha

class gamma : public beta, public alpha{ int x;public:

alpha(int i){ x i; }

class gamma : public beta, public alpha{  int u, v;public:gamma(int a, int b, float c) : 

l h ( * 2) b ( ) ( ){  x = i; }void show_alpha(){  cout<<x; }};

class beta

alpha(a * 2), beta(c, c), u(a){  v = b; }void show_gamma(){  cout<<u<<v; }};class beta

{ float p, q;public:

beta(float a, float b) : p(a), q(b + p)

{ ; }};void main(){  gamma g(36, 7, 2.5);g.show_alpha();g show beta();( , ) p( ), q( p)

{}void show_beta(){  cout<<p<<q; }};

g.show_beta();g.show_gamma();}

Data members are initialized in the order of their declaration

ContainershipContainership • An object can be a collection of other objectsclass gamma{ ……

l halpha a;beta b;

public:public:gamma(arglist) : a(arglist1), b(arglist2){ …… }………};

• The constructors of member objects are called in the order in which they are declared in the nested classorder in which they are declared in the nested class

PointersPointers class item{ int code;

float price;public:

void getdata(int a, float b){ b }{   code = a; price = b;}void show(){ cout<<code<<price; }};

item x;item x;item *ptr = &x;ptr‐>getdata(12, 3.5);ptr‐>show(); or (*ptr) show();ptr >show(); or ( ptr).show();item *ptr = new item;ptr‐>getdata(45, 6.9);item *ptr = new item[10]; array of objectsp [ ]; y jptr(i)‐>show();

Array of Pointers to ObjectsArray of Pointers to Objects#include<iostream.h>#i l d t i h#include<cstring.h>using namespace std;class city{ protected:

int main(){  city *cptr[10];{ p

char *name;int l;

public:city()

int n = 1;int option;do{ cptr[n] = new city;city()

{  l = 0;name = new char[l + 1]; }

void getname()

{ cptr[n]   new city;cptr[n]‐>getname();n++;cout<<“Continue (1/0)”;i ti{  char *s;

s = new char[10];cin>>s;l = strlen(s);

cin>>option;} while(option); }

l = strlen(s);name = new char[l + 1];strcpy(name, s);}};

this pointerthis pointerclass person int main(){  char name[10];int age;public:person(char *s int a)

{  person P1(“Rony”, 35), P2(“Johny”, 25), P3(“Mani”, 45);

person P = P1.greater(P3);Pdisplay();person(char *s, int a)

{  strcpy(name, s);age = a; }

person & person :: greater(person & x)

P.display();P = P1.greater(P2);P.display(); }

person & person :: greater(person & x){  if (x.age >= age)

return x;else

return *this; } return the object it points tovoid display(){  cout<<name<<age; }};

• a pointer that points to the object for whichthis function was called

Pointer to Derived ClassPointer to Derived Classclass BC int main()

{ BC *bptr;{  public:

int b;id h ()

{  BC *bptr;BC base;bptr = &base;bptr‐>b = 100;

void show(){  cout<<b;}};

class DC : public BC

bptr‐>show();DC derived;bptr = &derived;bptr‐>b = 200;class DC : public BC

{ public:int d;

bptr >b = 200;bptr‐>d = 300; Errorbptr‐>show();DC *dptr;

void show(){  cout<<b<<d; }};

dptr = &derived;dptr‐>d = 300;dptr‐>show();((DC *)bptr)‐>d = 400;(( C )bptr) d 400;((DC *)bptr)‐>show(); }

Virtual FunctionVirtual Functionclass Base{ bli

void main(){ Base B *bptr;{ public: 

void display() { cout<<“Display Base”; }virtual void show()

{  Base B,  bptr;Derived D;bptr = &B;bptr‐>display();Base version()

{ cout<<“Show Base”; }};class Derived: public Base{ public:

void display()

p p y();bptr‐>show();  Base versionbptr = &D;bptr‐>display();Base version

void display(){  cout<<“Display Derived”; }void show(){  cout<<“Show Derived”; }};

bptr‐>show(); Derived version}

Pure Virtual Function is declared in a base class that has no definition relate to the base class. In such cases, each derived class should contain a  definition of the function or redeclare the function as a pure virtual function

virtual void display() = 0;A class containing pure virtual functions cannot be used to declare any objects its own. 

Such classes are called abstract base classes. These classes are used to create a base pointer required for achieving run time polymorphism

FilesFiles 

• A file is a collection of related data stored in aA file is a collection of related data stored in a particular area on the disk

• I/O system of C++ uses file streams as an• I/O system of C++ uses file streams as an interface between the programs and the files. Input stream reads data from the file andInput stream reads data from the file and output stream writes data to the file

E d f filEnd‐of‐file• while(file1) or if(file1.eof() == 0)

File I/OFile I/O#include<iostream.h>#include<fstream.h>void main(){  ofstream outf(“ITEM”); ofstream outf; outf.open(“ITEM”);

char name[10];char name[10];float cost;cin>>name>>cost;outf<<name<<“\n”<<cost;outf<<name<< \n <<cost;outf.close();ifstream inf(“ITEM”);inf>>name;;inf>>cost;cout<<name<<cost;inf.close(); }

Multiple FilesMultiple Files

void main() Stream_object.open(“file name”, mode);(){ char line[80];ifstream file1, file2;

_ j p ( , );File mode

Parameter Meaning

file1.open(“country”);file2.open(“capital”);

ios::app Append

ios::ate Go to end‐of‐file

ios::binary Binary filefile1.getline(line, 80);cout<<line;fil 2 li (li 80)

ios::binary Binary file

ios::in Read only

ios::nocreate Open fails if file doesn’t exist

file2.getline(line, 80);cout<<line; }

ios::noreplace Open fails if file already exists

ios::out Write only

ios::trunc Delete the contents of the file

Sequential I/OSequential I/O#include<fstream.h>void main(){ char c, s[20];

cin>>s;int l = strlen(s);fstream file;file.open(“Text”, ios::in | ios::out);for (int i = 0; i < l; ++i)file.put(s[i]);file.seekg(0);g( );while(file){  file.get(c);cout<<c; }; }

}

Binary I/OBinary I/O#include<iomanip.h>

()void main(){ float height[4] = {1.2, 3.45, 9.3, 23.6};

ofstream outfile;outfile open(“Binary”);outfile.open(“Binary”);outfile.write((char *) & height, sizeof(height));outfile.close();ifstream infile;ifstream infile;infile.open(“Binary”);infile.read((char *) & height, sizeof(height));for (int i = 0; i < 4; ++i)( ; ; ){  cout.setf(ios::showpoint);cout<<setw(10)<<setprecision(2)<<height[i]; }

infile.close(); }

Object I/Oclass inventory{ char name[10]; Object I/O

int code;public:

void readdata(){ cin>>name>>code; }{ cin>>name>>code; }void writedata(){ cout<<setiosflags(ios::left)<<setw(10)<<name<<setiosflags(ios::right)<<setw(10)<<code<<endl; }};code<<endl; }};

void main(){ inventory item[3];

fstream file;file.open(“stock.dat”, ios::in | ios::out);for (int i = 0; i < 3; ++i){ item[i].readdata();file.write((char *) & item[i], sizeof(item[i])); }file.write((char  ) & item[i], sizeof(item[i])); }file.seekg(0);for(i = 0; i < 3; ++i){ file.read((char *) & item[i], sizeof(item[i]));i [i] i d () }item[i].writedata(); }file.close(); }

Random AccessRandom Accessvoid main(){ inventory item; class inventory

fstream inoutfile; cout<<“Enter object No: “;inoutfile.open(“stock.dat”, ios::ate | ios::in | ios::out | ios::binary);inoutfile.seekg(0, ios::beg);while(inoutfile.read((char *) & item, sizeof(item)))

cout<< Enter object No:  ;int object;cin>>object;int location=(object – 1)*sizeof(item);i fil k (l i )while(inoutfile.read((char  ) & item, sizeof(item)))

item.writedata();inoutfile.clear(); turn off EOF flagitem.getdata();i tfil it (( h *) & it i f(it ))

inoutfile.seekp(location);item.getdata();inoutfile.write((char *) & item,

sizeof(item));inoutfile.write((char *) & item, sizeof(item));inoutfile.seekg(0);while(inoutfile.read((char *) & item, sizeof(item)))

item.writedata();

( ));Inoutfile.seekg(0);whie(inoutfile.read((char *) & item,

sizeof(item)))item writedata();();

int last = inoutfile.tellg();int n = last / sizeof(item);cout<<“No of bytes : “<<n;cout<<“Total bytes : “<<last;

item.writedata();inoutfile.close();}

cout<< Total bytes  :  <<last;