heritage de fonctions

Comment fait on lorsqu'on a definie une classe A qui herite
d'une autre B pour appeler les fonctions de la classe de base
A pour qu'elles soient utilisables dans la classe B qui
herite.
Comment faire au niveau de la prog pour ne pas melanger
les fonctions heritées de A et les nouvelles fonctions definies
dans la classe B.
ESt il possible d'avoir un bout de code le plus simple et
clair possible.MERCI BONNE PROG!

alors....
quand tu dérive une classe Mere en une classe Fille, la classe Fille recoit de sa mere par heritage toutes les fonctions membres sauf les constructeurs, tu peux donc appeler toutes les autres fonctions. pour interdire une de ces fonctions a la classe fille, soit ds la classe fille tu met cette fonction en private, soit tu la réécris pour qu'elle ne fasse rien ou qu'elle leve une exception. a priori, il faut la mettre en private vu que cette derniere solution est plutot stupide si tu dois faire passer cette classe a quelqu'un, il sera incapable de savoir ce que tu as fait. pour qu'une fonction n'aie pas le meme comportement entre classe mere et classe fille, il faut la réécrire dans la classe fille. voila, tu sais a peu pres tt sur les comportements des fonctions héritées, en esperant que ca soit clair, et que je n'ai rien oublié ni dis de conneries

une classe dérivée hérite des méthodes et des membres de la classe de base si leur visibilité est au moins protected

si tu spécifies une methode virtuelle dans la classe de base, elle pourra etre redéfinie dans une classe fille

si cette methode virtuelle n'a pas de définition dans la classe de base (suivie de =0), la classe de base est abstraite, elle ne pourra etre hinstanciée et servira juste de model pour les classes filles

// une classe de base abstraite, c'est à dire qui ne peut
// etre hinstanciée
struct Foo_base
{
// le constructeur par defaut
Foo_base() : i(5) {}

// methode virtuelle pure qui rend la classe abstraite
virtual int bar() = 0;

protected:

int i;

};

struct Foo_derived1 : Foo_base // heritage public
{

// appel du constructeur de la classe de base
Foo_derived1() : Foo_base() {}

// methode bar definie
int bar()
{
return i;
}
};

// herite des membres et methodes de Foo_derived1
struct Foo_derived2 : Foo_derived1
{
Foo_derived2() : Foo_derived1() {}
};


int main()
{
Foo_derived2 f;

// affiche 5
std::cout << f.bar() << '\n';
}