Bonjour,
 
voilà je suis en train d'apprendre la programmation c++ et il y a diverses choses que je ne comprends pas :  
 
- quand passe-t-on un argument par référence a une fonction? desfois dans les corrections ils le font alors que l'argument n'est pas modifié
meme question quand on retourne une référence avec les fonctions  
 par exemple pour la surcharge de l'opérateur =
il retourne une référence et ils passent l'argument a droite (donc celui qui n'est pas modifié) par reference
 
- quand déclare-t-on une fonction amie a une classe? j'ai bien compris que cela servait a ce que la fonction ait accès aux parties privées de la classe mais je doute quon le fasse systématiquement (sinon a quoi bon déclarer des méthodes ou des attributs en private)
 
- comment choisir si une méthode doit etre définit a l'intérieur ou a l'extérieur d'une classe ?
 
 
merci d'avance pour votre aide
 
 

 
 
Salut, moi aussi je suis en train d'apprendre mais je peux peut etre t'apporter quelques réponses.
 
- On fait ça pour des paramètres de type class (ou struct). Quand tu passe un élément à une fonction par valeur, au sein de la fonction une variable interne de même type est recrée et la valeur du premeir element est recopiée dans le second. Si t'as une classe avec une dizaine d'attributs, ca prend de la place en mémoire pour rien durant l'execution de ta fonction. Ainsi, on lui passe juste son adresse (beaucoup plus leger), par le passage de paramètres par reference.
Il ne faut absolument pas voir ca comme si on voulait modifier l'element initial ! (par exemple si la fonction retourne déja autre chose). Il est tout à fait possible de voir void mafonc(const maclasse & nomvar) (la c'est clair qu'on veut pas le modifier).
 
- Les fonctions amies c'est pas bien   . Donc non, on ne le fait pas systematiquement. Si une classe a des attributs de type une autre classe, alors il faut voir du coté des objets emboités.
 
- Une methode est toujours déclarée à l'interieur d'une classe. Sinon c'est une fonction.
 
Voila, j'espere avoir été clair  

 
quand on veut pas en faire une copie (c'est a dire, tres souvent pour les types non primitifs)
 

 
generalement c'est qu'on renvoie une variable membre. On colle (d'ailleurs on renvoie une reference "const" )
 

 
a peu pres jamais
 

 
c'est ton design, ca. Ca viendra avec le temps et les gamelles
 

Tu passes par référence quand il s'agit d'objet que tu as créé toi même (tes propres classes par exemple).
Tu passes par adresse quand il s'agit de int, float, double, char, etc... et que tu dois modifier la valeur dans la méthode
Tu passes par valeur quand tu ne dois pas modifier la valeur (int, float, double, char, etc...)
 
Enfin c'est les règles de bonnes pratiques qu'on apprend à l'école et dans les livres.  
Mais en pratique, sincèrement je préfère de loin les pointeurs que les références en C++.
 
Par contre, dans d'autre langage comme le C# et le JAVA, il n'existe plus que des références. Enfin il y a encore des pointeurs, mais c'est plus si facile de les utilisés car il faut mettre diverses choses en place pour les exploiter...

nan ca ressemble plus a des pointeurs
 
 

 
Si je comprend bien ta question, tu voudrais un passage d'argument par référence constante ? Tu as sans doute raison, si l'argument n'est pas modifié.
 

 
Foo & operator=( Foo const & ); normalement
 

 
pour surcharger des operateurs non membre, comme l'inserteur ou l'extracteur (<<, >>, ...), ça a un sens.
Meme si d'autre te dirons peut etre, c'est la mal, t'as qu'a faire une fonction membre publique print() et l'operateur (inline) appelle print(). Je trouve ça inélégant au possible.
 

si tu *defini* une fonction membre à l'interieur d'une classe, celle-ci est implicitement inline. Ce n'est généralement pas souhaitable, sauf peut-etre dans le cas de fonctions tres courtes comme les accesseurs par exemple.
 

oups attendez je crois que j'ai confondu définit et déclarer
 
comment choisir si on déclare la fonction a lintérieur ou a l'extérieur de la classe?
 
il me semble que la plupart du temps on declare a l'intérieur et on définit a l'extéireur
 
mais desfois on fait le tout a l'extérieur
comment choisir?

 
Si ta fonction n'a pas besoin d'avoir l'acces aux membres privés ou protégés de ta classe, fais en une fonction libre, non friend. (pas le cas le plus courant)
Dans le cas contraire, fais en une fonction membre.
Et enfin, certaines surcharges d'operateurs ne peuvent pas etre défini en tant que membre, mais ont besoin des membres protégés ou privés de ta classe. A ce moment la, fais en une fonction libre, friend.

 
L'operateur << par exemple ?
 
Je ne comprends pas, pour faire la surcharge de cet operateur il suffit de déclarer une fonction exterieure, de delui fournir la classe en paramètres et de créer des accesseurs, non ?
Qu'es ce que "friend" vient faire la dedans ?

 
Oui.
 

 
ça t'oblige à créer des accesseurs, et une fonction fantome, qui jouera le même rôle que l'operateur, et qui sera publique si elle est membre.
 

 
tu ne vois vraiment pas ?

 
Si on adopte la première solution, la seconde devient inutile.
Et la première n'est pas meilleure ? (moi c'est ce qu'on m'a appris)

 
Rien compris, quelles sont les deux solutions dont tu parles ?

En fait, je parlais de surcharge de l'operateur << dans le but de l'utiliser pour afficher le contenu des attributs d'une classe (c'est la seule que j'ai eu l'occasion d'utiliser), donc dans ce cas, soit on utilise des accesseurs, soit une fonction amie (on m'a vivement recommandé les accesseurs).
Donc j'aurais voulu savoir si dans certains cas l'utilisation de fonction amie était préférable... etant donné que t'as l'air de dire que c'est bien alors qu'on m'a toujours dit d'eviter au maximum (je parle de cas ou l'utilsation de fonction amie n'est pas la seule solution).

 
et on a bien fait. Si tu as des accesseurs, tu t'en sers. Tu les met inline si c'est pénalisant en performance, ou si tu l'anticipes. Et tu évites le friend.  
Mais il y a des cas ou tu n'a pas (envi/usage de fournir des) d'accesseurs, alors friend est la pour ça.
 

.
 
*dans certains cas*, l'utilisation d'une fonction friend inline est avantageuse. Pour une classe ayant un constructeur délibérement non explicit (à voir en seconde lecture).

 
 
quelles sont les surcharges d'operateur qui ne peuvent etre defini en tant que membre et pourquoi?

les operateurs << et >>. Ce sont les seuls en fait. Il y en a d'autre pour lesquels il n'est pas judicieux d'en faire des fonctions membres. C'est à voir quasiment au cas par cas. Et c'est presque à retenir par coeur parce que c'est assez piegeux
 
pourquoi << et >> ?
struct Foo {};
Foo foo;
tu écris cout << foo;
C'est interprété soit en (1) operator<<(std::ostream, foo), soit en (2) std::ostream::operator<<( foo )
 
(2) n'existe pas dans basic_ostream<>. Donc il faut utiliser (1)
Idem pour >>.

 
par contre, pour emuler un operator<< virtuel, j'aime bien faire ça :
 

c'est balot de prendre une reference sur un ostream pour ensuite aller ecrire sur std::cout sans rien demander a personne

ouais bon,    
 
    * class B
    * {
    * public:
    *       virtual ~B() {}
    * private:
    *     virtual void print( std::ostream& os ) const = 0;
    *      
    *     friend inline std::ostream& operator<<( std::ostream& os, B const & b )
    *     {
    *         b.print( os );
    *     }
    * };
    *
    * class D : public B
    * {
    * private:
    *     virtual void print( std::ostream& os ) const { os << "hehon"; }
    * };
    *
    * int main()
    * {
    *     B* d = new D();
    *     std::cout << *d;
    *     delete d;
    * }

Faut être précis, on est sur un topic débutant mon cher, pédagogie et clarté

Ah ? Je croyais que pour un topic débutant c'était plutot et RTFM nOOb. Au temps pour moi.