Relations d'héritage entre les classes (Suite)

Dr SIDIBE A. MA, ENI-ABT

L'accessibilité de la classe dérivée dans l'héritage public est la suivante:

▪ La classe dérivée peut accéder aux membres publics de la classe parent.

▪ La classe dérivée peut accéder aux membres protégés de la classe parent.
▪ La classe dérivée ne peut pas accéder aux membres privés de la classe parent.

L'accessibilité d'un objet de classe dérivée est la suivante :

▪ L'objet de la classe dérivée peut accéder aux membres publics de la classe parent.
▪ L'objet de la classe dérivée ne peut pas accéder aux membres protégés de la classe parent.
▪ L'objet de la classe dérivée ne peut pas accéder aux membres privés de la classe parent.
 L’Accessibilité de la Classe Dérivée et de l’Objet de la Classe Dérivé
dans l’Héritage Public
Classe Parent
Private
Protected
Public

Héritage Public

Private
Protected
Public Objet de la classe derivée

Classe Derivée

La figure ci-dessus montre que les membres privés, protégés et publics de la classe dérivée peuvent accéder
aux membres protégés et publics de la classe parent. Cependant, l'objet de la classe dérivée ne peut
accéder directement qu'aux membres publics des deux classes.
 Exemple d’Accessibilité de la Classe Dérivée et de l’Objet de la Classe Dérivé
dans l’Héritage Public void Enfant::input()
Exercice { cout<<"Entrez a:";
#include <iostream>
cin>>a;
Ecrire un programme qui using namespace std;
cout<<"Entrez b:";
class Parent
déclare deux classes et définit cin>>b;
{
/*
public:
une relation entre elles en cout<<"Entrez c:";
int a;
cin>>c;
protected:
utilisant l'héritage public. */
int b;
}
private:
void Enfant::output()
int c;
{ cout<<"a = "<<a<<endl;
};
cout<<"b = "<<b<<endl;
class Enfant : public Parent
}
{
int main()
public:
{ Enfant obj;
void input();
obj.input();
void output();
obj.output();
};
return 0;
}
Héritage Protégé
Dans l'héritage protégé, le statut d'accès des membres de la classe parent dans la classe
dérivée est restreint. Les membres publics de la classe parent deviennent des membres
protégés de la classe dérivée. Les membres protégés de la classe parent deviennent des
membres protégés de la classe dérivée. Les membres privés de la classe parent deviennent
des membres privés de la classe dérivée.

Syntaxe
La syntaxe de définition de l'héritage protégé est la suivante :
class class_enfant : protected class_parent
{
Le corps de la classe
}
L'accessibilité de la classe dérivée dans l'héritage protégé est la
suivante:
▪ La classe dérivée peut accéder aux membres publics de la classe parent.
▪ La classe dérivée peut accéder aux membres protégés de la classe parent.
▪ La classe dérivée ne peut pas accéder aux membres privés de la classe parent.

L'accessibilité d'un objet de classe dérivée est la suivante :

▪ L'objet de la classe dérivée ne peut pas accéder aux membres publics de la classe parent.
▪ L'objet de la classe dérivée ne peut pas accéder aux membres protégés de la classe parent.
▪ L'objet de la classe dérivée ne peut pas accéder aux membres privés de la classe parent.
 L’Accessibilité de la Classe Dérivée et de l’Objet de la Classe Dérivé
dans l’Héritage Protégé
Classe Parent
Private
Protected
Public

Héritage Protégé

Private
Protected
Public Objet de la classe derivée

Classe Derivée

La figure ci-dessus montre que les membres privés, protégés et publics de la classe dérivée peuvent
accéder aux membres protégés et publics de la classe parent. Cependant, l'objet de la classe dérivée ne
peut accéder directement qu'aux membres publics de la classe dérivée. l'objet de la classe parent ne
peut accéder directement à aucun member de la classe parent.
 Exemple d’Accessibilité de la Classe Dérivée et de l’Objet de la Classe Dérivé
Exercice dans l’Héritage Protégé void Enfant::input()
{ cout<<"Entrez a:";
Ecrire un programme qui #include <iostream>
cin>>a;
using namespace std;
déclare deux classes et définit cout<<"Entrez b:";
class Parent
cin>>b;
{
une relation entre elles en public:
/*
cout<<"Entrez c:";
int a;
utilisant l'héritage protégé. cin>>c;
protected:
*/
NB: int b;
}
private:
La principale différence entre void Enfant::output()
int c;
{ cout<<"a = "<<a<<endl;
l'héritage public et l'héritage };
cout<<"b = "<<b<<endl;
class Enfant : protected Parent
protégé est que les membres }
{
int main()
public:
publics de la classe parent { Enfant obj;
void input();
obj.input();
deviennent protégés pour la class void output();
obj.output();
};
dérivée dans l'héritage protégé. return 0;
}
Héritage Privé

Dans l'héritage protégé, le statut d'accès des membres de la classe parent dans la classe
dérivée est restreint. Les membres publics, protégés et privés de la classe parent
deviennent tous des membres privés de la classe dérivée.

Syntaxe
La syntaxe de définition de l'héritage privé est la suivante :
class class_enfant : private class_parent
{
Le corps de la classe
}
 L'accessibilité de la classe dérivée dans l'héritage privé est la suivante:

▪ La classe dérivée peut accéder aux membres publics de la classe parent.

▪ La classe dérivée peut accéder aux membres protégés de la classe parent.
▪ La classe dérivée ne peut pas accéder aux membres privés de la classe parent.

L'accessibilité d'un objet de classe dérivée est la suivante :

▪ L'objet de la classe dérivée ne peut pas accéder aux membres publics de la classe parent.
▪ L'objet de la classe dérivée ne peut pas accéder aux membres protégés de la classe parent.
▪ L'objet de la classe dérivée ne peut pas accéder aux membres privés de la classe parent.
 L’Accessibilité de la Classe Dérivée et de l’Objet de la Classe Dérivé
Classe Parent
dans l’Héritage Privé
Private
Protected
Public

Héritage Privé

Private
Protected
Public Objet de la classe derivée

Classe Derivée
La différence principale entre l’héritage public et l’héritage privé est que l’héritage privé est
généralement utilisé pour restreindre l’accès à la classe parent par des classes qui sont dérivées de la
classe enfant. Dans l’héritage privé, tous les membres publics et protégés de la classe parent deviennent
des membres privés dans les objects de la classe dérivé. Ils ne sont pas accessible par les fonctions des
classes dérivées de la classe enfant.
 Exemple d’Accessibilité de la Classe Dérivée et de l’Objet de la Classe Dérivé
Exercice dans l’Héritage Privé void Enfant::input()
{ cout<<"Entrez a:";
Ecrire un programme qui #include <iostream>
cin>>a;
using namespace std;
déclare deux classes et définit cout<<"Entrez b:";
class Parent
cin>>b;
{
une relation entre elles en public:
/*
cout<<"Entrez c:";
int a;
utilisant l'héritage protégé. cin>>c;
protected:
*/
NB: int b;
}
private:
La principale différence entre l'héritage void Enfant::output()
int c;
privé et les autres héritages est que { cout<<"a = "<<a<<endl;
};
cout<<"b = "<<b<<endl;
toutes les données membres de la class Enfant : private Parent
}
classe parent deviennent des membres {
int main()
public:
privés de la classe dérivée. Toute classe { Enfant obj;
void input();
qui hérite de la classe dérivée ne peut obj.input();
void output();
obj.output();
accéder à aucun membre de la classe };
return 0;
dérivée. }
Rédéfinition de fonction (Function Overriding)
Le processus de déclaration de la fonction membre dans la classe dérivée avec le même nom et la
même signature dans la classe parent est appelé rédéfinition de fonction.
Le rédéfinition de fonction permet à l'utilisateur d'utiliser les mêmes noms pour appeler les
fonctions membres de différentes classes. Lorsqu'une fonction membre est redéfinie dans la classe
dérivée, l'objet de la classe dérivée ne peut pas accéder à la fonction de la classe parent.
Cependant, la fonction de la classe parent est accessible en utilisant la résolution de portée.
Le rédéfinition de fonction permet de redéfinir une fonction de la classe de base à l'intérieur de la
classe dérivée, qui remplace la fonction de la classe de base. Le rédéfinition de fonction est une
implémentation du polymorphisme d'exécution. Ainsi, il remplace la fonction au moment de
l'exécution du programme.
 Exemple de redéfinition de fonction
#include <iostream>
using namespace std;
class Parent
{
protected: class Child : public Parent
void Child::show() // rédenition de la fonction show()
int n; {
{
public: private:
Parent::show();
Parent(); char ch;
cout<<"ch = "<<ch<<endl;
Parent(int p); public:
}
void show(); Child();
int main()
}; Child(char c,int m);
{
Parent::Parent() void show();
Child obj1('@',100);
{ };
cout<<" Obj1 est défini comme suit:\n" ;
n = 0; Child::Child():Parent()
obj1.show();
} {
return 0;
Parent::Parent(int p) ch= 'x';
}
{ n = p; }
} Child::Child(char c,int m):Parent(m)
void Parent::show() {
{ ch = c;
cout<<"n = "<<n<<endl; }
}
 Comment fonctionne le programme ci-dessus ?

Le programme ci-dessus déclare deux classes. Les deux classes déclarent une fonction membre
show() pour afficher la valeur des données membres. La classe dérivée remplace la fonction
show(). L'objet de la classe dérivée ne peut pas utiliser cette fonction directement. L'objet
de la classe dérivée appelle la fonction déclarée dans la classe dérivée. La fonction
membre de la classe dérivée appelle ensuite la fonction de la classe parent avec
l'instruction suivante :
Parent::show();
Exercice
Ecrire un programme qui déclare deux classes. La classe parent est appelé Simple qui a
deux membres de données a et b pour stocker deux nombres. Il a également quatre fonctions
membres :
▪ La fonction add() additionne deux nombres et affiche le résultat.
▪ La fonction sub() soustrait deux nombres et affiche le résultat.
▪ La fonction mul() multiplie deux nombres et affiche le résultat.
▪ La fonction div() divise deux nombres et affiche le résultat.
La classe enfant est Complexe qui remplace les quatre fonctions. Chaque fonction de la
classe enfant vérifie la valeur des données membres. Il appelle la fonction membre
correspondante dans la classe parent si les valeurs sont supérieures à 0. Sinon, il affiche un
message d'erreur.
#include <iostream> void Simple::in() class Complex: public Simple
using namespace std; { cout<<"Entrez a:"; {
class Simple cin>>a; public:
{ cout<<"Entrez b:"; void add();
cin>>b; void sub();
protected:
} void mul();
int a, b;
void Simple::add() void div();
public:
{ };
Simple(); void Complex::add()
cout<<"a + b="<<a+b<<endl;
void in(); {
}
void add(); if(a<=0 || b<=0)
void Simple::sub()
void sub(); { cout<<"Valeurs Invalides"<<endl;
void mul(); cout<<"a - b="<<a-b<<endl; else
void div(); Simple::add();
}
}; }
void Simple::mul()
Simple::Simple() void Complex::sub()
{
{ {
cout<<"a * b="<<a*b<<endl;
if(a<=0 || b<=0)
a=0; } cout<<"Valeurs Invalides"<<endl;
b=0; void Simple::div() else
} { Simple::sub();
cout<<"a/b="<<a/b<<endl; }
}
void Complex::mul()
int main(){
{ if(a<=0 || b<=0)
Complex obj;
cout<<"Valeurs Invalides"<<endl;
obj.in();
else
obj.add();
Simple::mul();
obj.sub();
}
obj.mul();
void Complex::div()
obj.div();
{ if(a<=0 || b<=0)
return 0;
cout<<"Valeurs Invalides"<<endl;
}
else
Simple::div();
}
 Héritage à Plusieurs Niveaux
Un type d'héritage dans lequel une classe est dérivée d'une autre classe dérivée est appelé héritage à
plusieurs niveaux ou Héritage multiniveaux. Dans l'héritage à plusieurs niveaux, les membres de la classe
parent sont hérités de la classe enfant et les membres de la classe enfant sont hérités de la classe grand-enfant. De
cette manière, les membres de la classe parent et de la classe enfant sont combinés dans la classe grand-enfant.
Exemple

Class A
{
Corps de la classe A
};
Class B: public A
{
Corps de la classe B
};
Class C : public B
{
Corps de la classe C
};
 Héritage à Plusieurs Niveaux
#include <iostream> class B:public A
using namespace std; { private:
class A int b;
{ private: public:
int a; void saisir(){
public: A::saisir();
void saisir(){ cout<<" Entrez b:";
cout<<" Entrez a:"; cin>>b;
cin>>a; }
} void afficher(){
void afficher(){ A::afficher();
cout<<"La valeur de a est:"<<a<<endl; cout<<"La valeur de b est:"<<b<<endl;
} }
}; };
 Héritage à Plusieurs Niveaux
class C:public B
{
private: Le programme déclare trois classes. La classe A est la
int c; classe parent et la classe B est la classe enfant de la classe
public: A. La classe C est la classe enfant de B. le programme
void saisir(){ déclare un objet obj de classe C. Lorsque obj appelle la
B::saisir();
fonction saisir(), le contrôle est passé à la fonction
cout<<" Entrez c:";
cin>>c; saisir() déclarée dans la classe C. L'instruction
} suivante déclarée dans la fonction saisir() de la classe
void afficher(){ C passe le contrôle vers la classe B:
B::afficher(); B::saisir();
cout<<"La valeur de c est:"<<c<<endl;
De même, l'instruction suivante déclarée dans la
}
}; fonction saisir() de la classe B passe à son tour le
int main(){ contrôle vers la classe A : A::saisir();
C obj; la fonction membre afficher s'exécute également de la
obj.saisir(); même manière. Les fonctions membres saisir() et
obj.afficher();
afficher() des trois classes sont surchargées.
return 0;
Exercice
Créez une classe Person qui a des attributs comme id, name et address. Elle a un constructeur
par défaut pour initialiser les données membres, une fonction membre pour la saisie et une
fonction membre pour l’affichage des données membres.
Créez une deuxième classe Student qui hérite de la classe Person. Elle a des attributs
supplémentaires comme numéro matricule et la moyenne. Elle a également une fonction
membre pour la saisie et une fonction membre pour l’affichage de ses données membres.
Créez la troisième classe Bourse qui hérite de la classe Student. Elle a des attributs
supplémentaires comme le nom de la bourse et le montant de la bourse. Elle a également
des fonctions membres pour la saisie et l’affichage de ses données membres.
 Programme
#include <iostream> void saisir(){
#include<string.h> cout<<"Enter your id :";
using namespace std; cin>>id;
class Person cout<<"Enter your name:";
{ cin>>name;
protected: cout<<"Enter your address:";
int id; cin>>address;
string name; }
string address; void afficher(){
public: cout<<"\n Les informations personnelle sont:\n";
Person(){ cout<<"id = "<<id<<endl;
id = 0; cout<<"Name = "<<name<<endl;
name=" "; cout<<"Address = "<<address<<endl;
address=" "; }
} };
class Student:public Person
Programme (suite) class Scholarship:public Student
{ {
private: private:
int nuMat; string sname;
int moyenne; int amount;
public: public:
Student(){ Scholarship(){
Person(); Student();
nuMat=0; sname=" ";
moyenne=0; amount=0;
} }
void saisir(){ void saisir(){
Person::saisir(); Student::saisir();
cout<<"Entrez votre numéro matricule:"; cout<<"Entrez le nom de la bourse:";
cin>>nuMat; cin>>sname;
cout<<"Entrez votre moyenne:"; cout<<"Entrez le montant de la bourse:";
cin>>moyenne; cin>>amount;
} }
void afficher(){ void afficher(){
Person::afficher(); Student::afficher();
cout<<"Le numéro matricule est:"<<nuMat<<endl; cout<<"Le nom de la bourse:"<<sname<<endl;
cout<<"La moyenne ="<<moyenne<<endl; cout<<"le montant de la bourse:"<<amount<<endl;
} }
}; };
 Programme (suite)
int main()
{
Scholarship obj;
obj.saisir();
obj.afficher();
return 0;
}
 Héritage à Plusieurs Niveaux Avec Paramètres

Les fonctions membres dans l'héritage multiniveau peuvent transmettre la valeur aux
fonctions membres des classes parents. Lorsqu'une fonction est redéfinie, la fonction membre
de la classe enfant appelle la fonction membre de la classe parent. Elle peut également
envoyer des valeurs de paramètre aux fonctions de la classe parent.
 Exemple
#include <iostream> class B:public A
using namespace std; {
class A private:
{ int b;
private: public:
int a; void set(int m, int n){
public: A::set(m);
void set(int x){
b = n;
a = x;
}
}
void out(){
void out(){
A::out();
cout<<" La valeur de a est:"<<a<<endl;
} cout<<" La valeur de b est:"<<b<<endl;
}; }
};
 Exemple
Le programme ci-dessus déclare trois classes avec
class C:public B
un héritage multiniveau. La fonction membre set()
{
de la classe A accepte un entier pour définir la
private: int main()
{ valeur du membre de données a. La fonction
int c;
C obj; membre set() de la classe B est surchargée et
public:
void set(int g, int h, int k){ obj.set(1,2,3); accepte deux entiers comme paramètre. Le

B::set(g,h); obj.out(); premier paramètre est passé à la fonction set() de

c = k; return 0; la classe A et le deuxième paramètre est utilisé

} } pour définir la valeur du membre de données b.

void out(){ La fonction membre set() de la classe C est à

B::out(); nouveau surchargée et accepte trois entiers
cout<<" La valeur de c est:"<<c<<endl; comme paramètres. Les deux premiers
} paramètres sont passés à la fonction set() de la
}; classe B et le troisième paramètre est utilisé pour
définir la valeur du membre de données c.
 Comment fonctionne le Programme ci-dessus ?

Le programme ci-dessus déclare trois classes avec un héritage multiniveau. La fonction

membre set() de la classe A accepte un entier pour définir la valeur du membre de données
a. La fonction membre set() de la classe B est surchargée et accepte deux entiers comme
paramètre. Le premier paramètre est passé à la fonction set() de la classe A et le deuxième
paramètre est utilisé pour définir la valeur du membre de données b. La fonction
membre set() de la classe C est à nouveau surchargée et accepte trois entiers comme
paramètres. Les deux premiers paramètres sont passés à la fonction set() de la classe B et le
troisième paramètre est utilisé pour définir la valeur du membre de données c.
Héritage Multiple
Une classe C++ peut hériter des membres de plusieurs classes. Le type d'héritage dans lequel
une classe dérivée hérite de plusieurs classes de base est appelé héritage multiple. Dans
l'héritage multiple, la classe dérivée combine les membres des classes de base.

Classe A Classe B

Classe C

Figure: Héritage multiple

 Héritage Multiple
La Syntaxe

La syntaxe de l'héritage multiple est la suivante :

class classe_enfant : accès classe_parent1, accès classe_parent2,....
Où :
- class est le mot clé qui est utilisé pour déclarer la classe.
- classe_enfant est le nom de la classe dérivée
- accès est le spécificateur d’accès et peut être public, protégé ou privé.
- classe_parent1 est le nom de la première classe de base
- classe_parent2 est le nom de la deuxième classe de base
 Héritage Multiple
Exemple:

class A
{ Dans l'exemple ci-contre, A et B sont deux classes
le corps de la classe A
indépendantes. La classe C hérite à la fois de A et de B.
};
class B Les membres de la classe A et de la classe B sont
{
le corps de la classe B combinés dans la classe C.
};
class C: public A, public B
{
le corps de la classe C
};
 Héritage Multiple
#include <iostream>
using namespace std;
class A class B

{ private: { private:

int a; int b;

public: public:

void saisirA(){ void saisirB(){

cout<<" Entrez a:"; cout<<" Entrez b:";

cin>>a; cin>>b;

} }

void afficherA(){ void afficherB(){

cout<<"La valeur de a est:"<<a<<endl; cout<<"La valeur de b est:"<<b<<endl;

} }

}; };
 Héritage Multiple
class C: public A, public B
{ private: int main()
int c;
{
public:
C obj;
void get(){
obj.get();
A::saisirA();
B::saisirB(); obj.show();
cout<<" Entrez c:"; return 0;
cin>>c; }
}
void show(){
A::afficherA();
B::afficherB();
cout<<"La valeur de c est:"<<c<<endl;
}
};
 Exemple d’héritage multiple
#include <iostream> // Base class PaintCost
using namespace std; class PaintCost int main()
// Base class Shape { {
class Shape public: Rectangle Rect ;
{ int getCost(int area) int area;
protected: { Rect.setWidth(5);
int width; return area*70 ; Rect.setHeight(7);
int height; } area = Rect.getArea();
public: }; // Print the area of the object.
void setWidth( int w) // Derived class cout<< "Total area: “
{ class Rectangle : public Shape, public PaintCost << Rect.getArea()
width = w; { << endl;
} public : // Print the total cost of painting
void setHeight( int h) int getArea() cout<<"Total paint cost: $"
{ { <<Rect.getCost(area)
height = h; return (width*height); <<endl;
} } return 0 ;
}; }; }
 Constructeurs en Héritage Multiple
Dans l'héritage multiple, les constructeurs des classes de base et des classes enfants sont
exécutés lorsqu'un objet de classe dérivée est créé. Les constructeurs peuvent accepter des
paramètres ou ils peuvent être sans paramètres.

Constructeurs sans Paramètre en Héritage Multiple

Les constructeurs sans paramètres peuvent être appelés à partir de la classe dérivée en
écrivant deux-points après le constructeur de la classe dérivée et le nom du constructeur
dans la classe parent.
 Constructeurs sans Paramètre en Héritage Multiple
#include <iostream>
using namespace std;
class A class C:public A, public B
{ {
public: public:
A() C():B(), A()
{ {
cout<<" le constructeur de la classe A:"<<endl; cout<<" Le constructeur de la classe C:"<<endl;
} }
}; };
class B int main()
{ {
public: C obj;
B() return 0;
{ }
cout<<" Le constructeur de la classe B:"<<endl;
}
};
Constructeurs avec Paramètre dans l’héritage Multiple

Les constructeurs avec des paramètres peuvent être appelés à partir de la classe dérivée en
écrivant deux-points après le constructeur de la classe dérivée et le nom du constructeur
dans la classe parent. Les valeurs requises pour le paramètre sont également fournies dans
l'appel aux constructeurs de la classe parent.
Constructeurs avec Paramètre dans l’héritage Multiple
#include <iostream>
class B
using namespace std;
{
class A
private:
{
int b;
private:
public:
int a;
B()
public:
{
A()
b = 0;
{
}
a = 0;
B(int n)
}
{
A(int n)
b = n;
{
}
a = n;
void showB()
}
{
void showA()
cout<<"b = "<<b<<endl;
{
}
cout<<"a = "<<a<<endl;
};
}
};
Constructeurs avec Paramètre dans l’héritage Multiple
class C: public A, public B
{ int main()
private: {
int c; C obj(1,2,3);
public: obj.showC();
C():B(), A() return 0;
{ }
c=0;
}
C(int x, int y, int z):A(x),B(y)
{
c=z;
}
void showC()
{
A::showA();
B::showB();
cout<<"c = "<<c<<endl;
}
};
 Ambiguïté dans l'héritage multiple

Un problème important dans l'héritage multiple est la question de l'ambiguïté. L'ambiguïté

est créée dans l'héritage multiple si les noms des fonctions sont similaires dans deux ou
plusieurs classes parents. Le compilateur ne peut pas déterminer quelle fonction
exécuter lorsque l'objet de la classe dérivée tente d'exécuter une telle fonction.
 Ambiguïté dans l'héritage multiple
#include <iostream> class C:public A, public B
using namespace std; {
class A public: Le programme ci-contre déclare trois
{ C():B(), A()
public: { classes. La classe A et la classe B ont
void show() }
{ toutes deux la fonction membre show().
};
cout<<“Class A”<<endl; int main() La classe C hérite simplement des deux
}
{
}; classes. Le programme déclare un objet
C obj;
class B
obj.show() de classe C. L'objet a deux fonctions
{
public: return 0;
} avec le même nom show(). Une fonction
void show()
{ provient de la classe A et la seconde de
cout<<“Class B”<<endl;
}
la classe B. Le compilateur générera une
}; erreur lors de la compilation du
programme ci-contre.
 Suppression de l'ambiguïté
L'ambiguïté peut être supprimée du programme ci-dessus comme suit :
obj.A::show();
obj.B::show();
une autre façon de supprimer l'ambiguïté dans l'héritage multiple consiste à surcharger les
deux fonctions dans la classe dérivée comme suit :
 Suppression de l'ambiguïté
Une autre façon de supprimer l'ambiguïté dans l'héritage multiple consiste à surcharger les deux fonctions dans
la classe dérivée comme suit : class C:public A, public B
{
#include <iostream>
public:
using namespace std;
void show()
class A
{ A::show();
{
public: B::show();
void show() cout<<“Class C”<<endl;
{ }
cout<<“Class A”<<endl;
} }
}; };
class B int main()
{ {
public: C obj;
void show() obj.show();
{ //obj.A::show();
cout<<“Class B”<<endl; //obj.B::show();
} return 0;
}; }