Discussion :

[hunter99]

slt ma question est tres simple ,comment on fait pour savoir si la fonction qui surcharge un operateur doit etre une methode amie ou pas ?
Merci bcp

[Médinoc]

Je dirais qu'elle a besoin d'être amie seulement si elle utilise des membres non-publics de la classe...

[NiamorH]

Je ne sais pas si la question n'était pas plutôt de savoir comment choisir un opérateur membre ou non membre ?

Si c'est bien ça ta question, alors saches qu'il est nécessaire de passer par un opérateur non membre lorsque ton objet se trouve en deuxième opérande d'un opérateur binaire.

Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Test
{};
 
Test t;
int i;
 
// Opérateur membre ok
t + i;
 
// Opérateur non membre obligé
i + t;

[hunter99]

ok merci bcp ,sinon en faisant un exercie j'ai rencontré un truc bizzare voila le code

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
tableau::tableau():nbvaleur(1),valeurs(new int)
{}
tableau::tableau(int nb):nbvaleur(nb),valeurs(new int[nb])
{
    for (int i=0;i<nbvaleur;i++)
    {
        valeurs[i]=0;
    }
    }
tableau::~tableau()
{
    delete [] valeurs ;
}
 
bool tableau::indice(int ind)const
{
    if (ind>0 && ind<nbvaleur)
    {
        return true;
    }
    throw("indice hors borne\n");
}
 
int& tableau::operator[](int ind)const
{
 
try
{
   indice(ind);
}
    catch(const char* erreur)
    {
        cout<<erreur<<endl;
    }
       return valeurs[ind];
}
 
 
 
int main()
{
    const tableau t(10); // le tableau est declaré comme constant mais je peux //le modifier
 
    cout<<t[1]<<endl;
    t[1]=1; // prq ça fonctionne ?
    cout<<t[1]<<endl;
    cin>>t[1];// de meme ici
    cout<<t[1];
    return 0;
 
}

merci

[NiamorH]

Ca fonctionne car l'opérateur [] est déclaré const mais il renvoie aussi une référence non constante vers un des éléments;

Si tu modifies le retour de l'opérateur [] de int & en int const & cela serait plus logique.

[Kujara]

Ca marche parceque ton operateur [] renvoie un int &.

la version correcte prends 2 operateurs [] :

Code :

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

1
2
3
4
5
6
const int & tableau::operator[](int ind)const
{
}
int& tableau::operator[](int ind)
{
}

L'un est const et renvoie un const int &, l'autre n'est pas const et autorise la modification de l'int renvoyé.

[hunter99]

ok merci bcp .

[Luc Hermitte]

slt ma question est tres simple ,comment on fait pour savoir si la fonction qui surcharge un operateur doit etre une methode amie ou pas ?

L'amitié est rarement nécessaire.
Dans le cas des opérateurs mathématiques, pour raisons de symétries, on rend les opérateurs binaires libres, et par commodité dépendant de ceux auto-modifiant (je ne trouve pas de meilleur nom)
->

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct T {
    T& operator+=(T const& rhs) { 
        ....
        // opérateur membre => l'amitié ne veut rien dire pour lui
    }
...
};
 
T operator+(T const& lhs, T const& rhs) {
    return T(lhs) += rhs;
}

Cas particulier: quand un opérateur lie deux classes différentes comme un vecteur et une matrice. Même en présence d'accesseurs qui vont bien (operateur[]), il est fréquent d'utiliser l'amitié pour raisons d'optimisation. Dans ce cas là, ce n'est pas choquant vu qu'il s'agit de toutes façons de classes très liées.

Pour les opérateurs liés aux flux, on peut s'en passer à l'aide de constructeurs d'initialisation (plus un moyen de mettre à jour une tierce donnée de même type (opérateur d'affection, swap, ...)), et des accesseurs qui vont bien.
Ceci dit, il est fréquent de voir ces opérateurs en amis (avec présence d'un constructeur par défaut).

[Jean-Marc.Bourguet]

Dans le cas des opérateurs mathématiques, pour raisons de symétries, on rend les opérateurs binaires libres, et par commodité dépendant de ceux auto-modifiant (je ne trouve pas de meilleur nom)

Si tu fais une multiplication de matrices, tu vas avoir tendance a implementer l'auto-modifiant en utilisant la version libre :-)

[Luc Hermitte]

(Plus un petit swap qui va bien.)
Ce pas faux. En effet. J'avais complètement zappé cette famille de cas.

[r0d]

Et pour la surcharge des opérateurs d'indirection de flux dans une classe template, vous feriez comment?

Par exemple, une classe Matrix qui implémente une matrice 2D template du style:

Code :

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

1
2
3
4
5
6
7
8
template <typename T>
class Matrix
{
// constructeurs, opérateurs, ...
 
private:
    std::vector<T> _matrix;
};

. Quelle serait la meilleure solution?

[Jean-Marc.Bourguet]

Et pour la surcharge des opérateurs d'indirection de flux dans une classe template, vous feriez comment?

Ils sont d'office externes à la classe et en général les classes ont une interface permettant de les implémenter sans les rendre friend (ou alors on peut se demander si ce n'est pas de l'aide au débuggage plus qu'une fonctionnalité de la classe).