bon, dans l´ordre :

• les références :

Passer un paramètre par référence à une fonction, il faut considérer que c´est pareil que le passer par pointeur pour les effets, mais que tu l´utilise comme si c´était passé par valeur.
Un exemple sera plus parlant :

void f1(int i)
{
i=10;
}

void f2(int* i)
{

• i=10;

}

void f3(int& i)
{
i=10;
}

void main()
{
int i,j,k;
i=j=k=5;
f1(i);f2(&j);f3(k);
//Ici, i vaut 5, mais j et k valent 10.
}

Tu vois que l´appel par référence est "plus simple
" que celui par pointeur, pour le même effet. Par contre, le désavantage est que lorsqu´on l´utilise, on peut ne pas s´apercevoir de ce que la variable que l´on passe en argument va être modifié.

il faut noter que la fonction suivante :

void f(T& var)
{
...
}

est strictement équivalente à :
void f(T* vart)
{
T& var=*vart;
...
}

et tu mets la même chose à la place des pointillé. Comme ça tu sais que la variable peut être modifié quand tu t´en sers (ce n´est pas à utilisé, mais ça permet de comprendre ce qui se passe).

La suite dans un autre post.

• l´héritage

J´avoue que là, tu m´as eu : je n´arrive pas à trouver un cas où l´utilisation d´un héritage privée est interessant. Pourtant, je suis sûr que ça doit exister.
Mais ne serait-ce qu´avec les fonction virtuelle (on y vient), ça peut trouver une application (un héritage dans lequel on ne peut pas directement utilisé une fonction héritée).

• les fonctions virtuelles

là c´est presque simple (la base). Encore avec un exemple :

class A
{
public:
/*virtual*/ void f();
};

class B : public A
{
public:
void f();
};

si maintenant, tu fait ça :

B objet1;
A objet2=B; //dans ce sens c´est autorisé.
objet2.f();

Quelle fonction f va être appelé ? pas de problèm
e, objet2 est une instance de la classe A donc c´est A::f() (la fonction f de la classe A) qui va être appelé.

Oui, mais parfois, comme objet2 est "en vrai" un objet de type B, on veut faire du traitement supplémentaire dans la fonction f, qu´elle soit appellé pour un objet de type B ou pour un objet de type A qui est "en vrai" un objet de type B.

Alors là, tu déclare f virtual dans la classe A, et ça veut dire, que lrosque que l´on utilise la fonction f, ça doit appeler la vrai fonction f de la classe de l´objet (sa "vraie" classe, et non pas celle que le compilateur peut voir au moment de la compilation).

Il faut noter que si tu appelle f dans le constructeur de A, alors même si tu es en train de construire un objet de type B, c´est la fonction f de la classe A qui est appelée, car à ce moment là, l´objet n´est pas encore de la classe B, mais seulement de la classe A.

• les static

Là, il faut séparer deux cas.

D´abord, le cas où tu utilise le mot clef static au niveau d´un fichier (c´est à dire, hors de toutes fonction).

Normalement, toutes variables ou fonctions déclaré au niveau d´un fichier est globale. C´est-à-dire que pourvu que les prototype où les déclaration avec le mot clef extern soit là, tu pourra utilisé cette variable ou cette fonction dans tout les fichiers de ton projet, et même au delà parfois. MAis ce n´est pas forcément ce que tu veux (ne serait-ce que sinon, tu ne peut pas donner deux fois le même nom a des variables glbale dans des fichiers différents, alors même que tu peut vouloir que la variable soit propore à un fichier).

Là, la solution est simple, tu mets le mot clef static. Ca veut dire que la variable est propre au fichier.

Dans le cas ou tu utilise ce mot clef pour une variable interne à une fonction, ça veut dire tout autre chose. LA ça veut dire que la variable n´est pas effacé entre chaque appel : la variable conserve sa valeur entre les différent appel de la fonction.

exemple:

void f()
{
static int i=10;
i++;
cout << i << endl;
}

void main()
{
f();
f();
f();
}

résultat :
11
12
13

Par contre, je t´avouerais que je ne sais pas ce qui se passe si la fonction est récursive où s´il y a plusieurs instances de la fonction qui peuvent tourner en même temps dans des threads différent. Peut-être que la variable est partagée, peut-être que la valeurs est sauvegardée à chaques sorties de fonction, ...
Il faudra voir avec quelqu´un qui connait vraiment le C++.

voila, donc à pars sur cette dernière interrogation et sur l´héritage privée, je crois avoir répondu à tes questions.

en tous cas je te remercie énormement je commence à comprendre un peu mieu même si je "bug" encore :p mais c´est normal je manque de pratique

encore merci ;)

Pour l´héritage privé, j´ai un exemple

Tu as fait une classe "Liste", avec plein de méthodes pour ranger devant, derriere, au milieu, bref, tout bien.

Tu veux faire une classe "Pile", qui est, en interne, une liste, MAIS !! ! a laquelle on n´autorise que l´ajout et le retrait en début.

On va faire hériter en private ou protected pour empecher l´utilisateur d´appeler toutes les fonctions de la classe mere (la liste), depuis la pile.

Entre private et protected, pour ce cas, je dirais que ça ne rentrera en jeu que si tu fais a nouveau une classe "TRUC", qui hérite de pile.
Mais la, je vois moins d´exemples...
(en fait j´emploie de moins en moins private et de plus en plus protected)

oui je vois

mais en faite je pense que protected à été crée pour l´héritage privé justement et que le private est utilisé si on veut pas faire d´héritage.
Enfin personnelement si je fais de l´héritage privé je pense que j´utiliserai les protected pour pas me casser la tête

ah oui, l´idée c´est que tu peut définir au cas par cas (pour chaque fonction ue tu hérite) si elle doit être public ou private ou protected (du moment que tu ne rend pas public un truc private dans la classe mère etc.).
Donc tu peut vouloir que les 350 fonctions membre d´une classe soit hérité de manière privée, sauf 3. là, tu ne t´emmerde par à tout redéfinir : tu hérite la classe de manière privé, et tu déclare juste tes trois fonctions public :

si on a :
class A
{
void f1();
void f2();
...
void f350();
};

on fait :
class B : private A
{
public:
void A::f348();
void A::f349();
void A::f350();
};

//je crois que la syntaxe est correcte, mais il fa
udrait vérifier.

oui mais le concept est là, je comprends tout à fait , c´est vrai que ca peut-être utile :D

Bonjour,

J´ai un petit problème d´héritage (je pense) donc j´essaie d´accéder à des données protected d´une autre class dont j´ai hérité voici un code abrégé :

class AG_indice{
protected:
int triangle_a, triangle_b, triangle_c;
int node_a, node_b, node_c;
public:
};

class AG_file : protected AG_indice{
...
}

seulement dans la class AG_file quand j´essaie d´accéder à triangle_a par exemple, il me dit que je suis pas autorisé :/

ai je oublié une étape ?

dans AG_indice, les membres sont deja protected, donc pas besoin de preciser dans ton heritage que tu veux que tout AG_file soit pretected.

class AG_file : AG_indice{
...
}

Sinon j´ai jamais utilisé protected donc je peux pas t´aider plus. Faut pas mettre un "friend" ?

Ok merci bon j´ai rectifié le protected, je me doutais que c´était pas ceci

par contre je pense que le "friend" ne s´applique que au fonction membre "publique" et même fonction tous court mais je suis vraiement pas sur, et étant donné que j´essaie d´accéder à des variables :/

class AG_file : public AG_indice{

}
et tu peux acceder a tes membre protected.

non toujours pas, enfin je pense que je décrypt bien l´erreur :

error C2248: ´triangle_a´ : cannot access protected member declared in class ´AG_indice´

j´ai mis :

class AG_file : public AG_indice{
class AG_file : AG_indice{
class AG_file : protected AG_indice{

toujours rien, mais il y a rien à faire avec le construteur ou autre ?

Donnes le code ou tu veux acceder a triangle_a stp.

http://rafb.net/paste/results/0OZ1Ay81.html

voilà, c´est le code source de mon header

je les commencé il n´y a pas longtemps donc il me reste pas mal de choses à faire.

Je ne vois pas ou tu accede a ton triangle_a de la classe fille.T´es sur que c´est le bon code ??

oh quel c** désolé j´avais mal vu :p par contre c´est un bout du code :

http://rafb.net/paste/results/Gw0wXR96.html

Quand tu met des membres protected tu ne peux pas y acceder que par les classes filles !
Toi tu essais d´acceder a triangle_a de AG_triangle_indice[], c´est un vecteur de AG_indice qui n´ont rien a voir avec AG_fille.
c´est pas parceque AG_fille a hérite de AG_indice qu´elle peut acceder a toutes les classes AG_indice que tu crées.

J´espere que c´est claire :s

oui mais alors comment accéder à des données protected d´une autre class ?

avec les fonctions :
Get_triangle_A(), Get_triangle_B()...
sinon tu peux pas.