Discussion :

[CLeBeR]

Bonjour,
J'ai un problème de compréhension à propos des passages par référence. Je suis en train de travailler sur les classes abstraites. Voici ma classe CExcFille qui permet de créer n'importe quel code erreur grâce au constructeur CExcFille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace
{
    class CExcFille : public CException
    {
        public :
        inline void _Edit()
        {
            cout << "Affichage de la fonction _Edit (class CEXcFille)" << endl;
        }
 
        CExcFille(const string & Libelle, const unsigned CodErr)
        {
 
        }
    };
}

Je voudrais comprendre pourquoi l'on passe le paramètre Libelle en référence alors que le CodErr non ?

Deuxièmement, j'ai une classe CEditable qui me permet d'afficher n'importe quel flux via l'opérateur << :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
namespace nsUtil
{
    class CEditable
    {
        public :
        virtual std::ostream & operator << (std::ostream & os,
                                const CEditable & Obj)
 
        {
                 return Obj._Edit(os);                  
        }
        virtual std::ostream _Edit( const std::ostream & os) =0;
        virtual ~CEditable (void);
    };
 
} 
 
 
{
    class CExcFille : public CException
    {
        public :
 
        inline virtual ostream &  _Edit (ostream & os)
        {
            return os << "Affichage de la fonction _Edit (class CEXcFille)" << endl;
        }
 
        CExcFille(const string & Libelle, const unsigned CodErr) : CException(Libelle,CodErr) {}
 
    };

Je ne comprends pas pourquoi la fonction renvoi un ostream et pourquoi est-il en référence ?

De même pour ces deux opérateurs, pourquoi l'un prend une référence et l'autre non ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        CDuree & operator ++ (void)                            throw ();
        CDuree   operator ++ (int)                             throw ();

Merci de votre aide !

[foetus]

Simple

• Passage par valeur -> 1 recopie/ appel du constructeur par recopie (*)
• Passage par référence -> 0 recopie (*)
• Retour référence -> Chaînage puisque le passage est par référence (**)

* -> Donc pour des POD (Plain Old Data) (***) on s'en fiche de la recopie.
Par contre, pas pour un object. Note la référence constante pour dire qu'on ne veut pas le modifier.

** -> Exemple: a = b + c + d
Cela va dépendre de l'ordre mais en gros cela donne b.operator+ ( c.operator+ (d) ).

Édit: @Bousk, *** Effectivement dans les POD il y a les "petites" struct/ class

[jo_link_noir]

Concernant les opérateurs ++:
- la pré-incrémentation (T & operator++() / ++i) permet d'incrémenter un objet puis retourne une référence sur lui même.
- la post-incrémentation(T operator++(int) / i++) fournit la valeur de l'objet (copie) et incrémente l'original.

C'est exactement le même comportement que les types hérités du C (int, etc),

[Bousk]

* -> Donc pour des POD (Plain Old Data) on s'en fiche de la recopie.

Pardon ?
Seuls les éléments primitifs/de base (char, int, ..) devraient être passés par copie, et certainement pas les POD. Un POD ça peut être conséquent, et y'a aucun intérêt à le copier dans tous les sens sauf à savoir ce qu'on fait.

[ternel]

En plus dans ton exemple, + étant associatif "left-to-right", ton exemple de chainage est en fait:

a = b + c + d équivaut à : a.operator=( operator+( operator+(b, c) , d) ).
Et ca n'illustre pas le chainage, car en général, + n'est pas une fonction membre.

Suppose une classe Assignment (inspirée de boost::assign)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <list>
template<typename Collection, typename Value>
class Assignment {
private:
    Collection& ref;
 
public:
    Assignment(Collection& ref, Value const& v) : ref(ref) {operator,(v);}
    Assignment& operator,(Value const& v) {ref.push_back(v); return *this;}
};
 
template<typename Collection, typename Value>
Assignment operator+=(Collection & c, Value const& v) {
    return Assignment(c), v;
}
 
int main() {
    std::list<int> l;
    l+=1, 2, 3;
    return 0;
}

La dernière instruction, l+=1, 2, 3;, se parenthèse ainsi: ((l+=1), 2), 3;.
Ca forme développée est en fait:
operator+=(l, 1).operator,(2).operator,(3);.

PS: J'aime bien cet exemple, on y trouve plein de chose sympa: Proxy, chaînage, template. Par contre, la vraie bibliothèque est plus complexe, plus complete, et plus sûre

[Astraya]

Seuls les éléments primitifs/de base (char, int, ..) devraient être passés par copie, et certainement pas les POD

Je ne serait pas aussi radical. Tout dépend du sizeof de ton POD. Un POD de 2*sizeof(int) est tout à fait copiable sans avoir de surcout par rapport à une mise en référence.

[stendhal666]

1. Le passage par référence est utile pour ne pas copier les objets "lourds". Dans le cas des types numériques natifs (int, float, char, etc.), une copie ne coûte pas suffisamment pour qu'on le passe par référence, il suffit donc de la passer par valeur. Cela dit, lorsqu'on passe l'argument par valeur, il n'est pas nécessaire de le déclarer const.

2. On retourne ostream& par référence pour le chaînage, en effet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::cout << 'a' << 'b' << 'c';

équivaut à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

((std::cout << 'a') << 'b') << 'c';

3. Du coup on passe le caractère 'c' au flux renvoyé par le passage du caractère 'b' au flux renvoyé par le passage de 'a' à std::cout.

4. Pour l'incrémentation, après ou avant, si tu y réfléchis, tu verras que la différence correspond au comportement désirable:
post-incrémentation: tu retournes la valeur actuelle et incrémentes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int x = 0;
std::cout << x++; // 0
std::cout << x; // 1

Du coup si tu retournais une référence, le premier cout << afficherait déjà 1, ce qui est contraire à la sémantique de l'opérateur...

[CLeBeR]

Bonsoir,
merci pour vos explications, cependant, je n'ai toujours pas compris pourquoi dans l'operateur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

CDuree   operator ++ (int)                             throw ();

on a un int en paramètre, alors que lorsque l'on fait i++, on ne spécifie pas de paramètre. De même, dans le premier opérateur, si je suis ma logique (qui n'est pas la meilleure ), étant donné qu'il y a un void, j'ai tendance à penser que ça correspond au i++, pourquoi ce n'est pas le cas ?


Deuxièmement, je n'ai toujours pas compris pourquoi dans la fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        virtual std::ostream & operator << (std::ostream & os,
                                const CEditable & Obj)

On spécifie un paramètre os.

Merci pour vos réponses !

[foetus]

Regarde la page Wiki: Operators in C and C++

Réponse 1:

Note: C++ uses the unnamed dummy-parameter int to differentiate between prefix and suffix increment operators.

Édit: Cela semble ultra-logique
Comme il n'y a qu'un seul opérateur alors ++a -> a.operator++() et a++ -> a.operator++().
Donc tu es chocolat

Et puisque tu vas le demander, en théorie, une signature d'une méthode/ fonction ne prend pas en compte le type de retour (juste les types des paramètres + le nom de la méthode/ fonction) donc impossible de les départager avec un type de retour différent.

[Astraya]

on a un int en paramètre, alors que lorsque l'on fait i++, on ne spécifie pas de paramètre. De même, dans le premier opérateur, si je suis ma logique (qui n'est pas la meilleure ), étant donné qu'il y a un void, j'ai tendance à penser que ça correspond au i++, pourquoi ce n'est pas le cas ?

Tu ne peux pas te baser sur le type de retour d'une fonction car en C++ le type de retour ne fait pas partie de la signature de la fonction. Ce qui fait la signature de la fonction sont : le nom de la fonction, les paramètres de la fonction et rien d'autre. Voila pourquoi si tu fais deux fonctions identiques avec deux types de retour différents ton compilateur te diras qu'il ne sait pas laquelle choisir car il ne regarde pas le type de retour pour savoir quelle fonction appeler mais le nom et les paramètres uniquement.

Ensuite pour le i++ à un paramètre car le compilateur va faire ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int int::operator(int& i) //this en paramètre
{
    int i_retour = i;
    i = i +1;
    return i_retour;
}

Il incrémente ton i et retourne la valeur avant incrémentation.

Pour le ++i il n'y a pas de paramètre car:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int int::operator() //pas de paramètre
{
    return this+1;
}

Il incrémente ton i et retourne "this" (ta valeur incrémentée)