Discussion :

[emmesse]

Bonjour,

quelle est la différence entre ces deux déclarations?

Code :

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

1
2
  nombre operator=(std::string nombre_str);//peut prendre un littéral
  nombre& operator=(std::string nombre_str);//peut prendre un littéral

quelqu'un a une idée?

[emmesse]

à quoi sert le '&' dans le type de retour de fonction?

[Stellar7]

C'est we, les gens ne sont peut-être pas à la plage, mais ils peuvent être ailleurs…

Peut-être un début de réponse sur Stackoverflow ?

En gros, il s'agit de référence pour laquelle le C++ refuse que ce soit nul.
Mais ce n'est pas moi ze spécialiste.

[dalfab]

Bonjour,

Le & pour un retour de fonction a la même signification qu'en déclaration de paramètre, qu'en déclaration de variable, qu'en qualificateur de this dans une déclaration de fonction! C'est un un peu à la base du C++, il indique une référence.

Plus de détails ici.

Ce qui distingue les 2 fonctions:
- la première retourne un objet nombre, ce qui n'a pas vraiment de sens ici car l'opérateur de génère pas de nombre!
- la seconde retourne une référence à un nombre, le code de l'opérateur terminant vraisemblablement par return *this;.

[foetus]

@dalfab confirme que cela ne sert à rien : je me posais la question.

Il faut vérifier mais pour les opérateurs, retourner 1 référence permet de chaîner les opérateurs.
Par exemple, si tu fais std::string& operator*(std::string&), après tu pourras faire str4 = str3 * str2 * str1. str2 * str1 va donc produire 1 std::string temporaire qui pourra être utilisé pour faire str3 * tmp.

D'ailleurs, avec les opérateurs, tu ne peux pas vraiment faire ce que tu veux en terme de paramètres ou de retour : tu es presque obligé pour certains de mettre des références (il faut lire les références pour cela)
Pareil pour les opérateurs amis (friend) : cela permet de mettre l'objet pas forcément à gauche mais aussi à droite.
Par exemple, si tu fais std::string& friend operator+(int)], après tu pourras faire str1 = str2 + 4 ou str1 = 4 + str2.

Il faut vérifier, surtout avec les différentes normes qui ont peut-être modifié les comportements du C++03

[jo_link_noir]

Il faut vérifier mais pour les opérateurs, retourner 1 référence permet de chaîner les opérateurs.
Par exemple, si tu fais std::string& operator*(std::string&), après tu pourras faire str4 = str3 * str2 * str1. str2 * str1 va donc produire 1 std::string temporaire qui pourra être utilisé pour faire str3 * tmp.

Cela aurait plus de sens de présenter str3 += str2 += str1; qui est horrible mais dont l'opérateur += retourne habituellement une référence. Ou simplement str3 = str2 = str1 puisqu'ici on parle de =. cppreference contient une page qui liste les prototypes usuels: https://en.cppreference.com/w/cpp/la...ions#Operators (il faut cliquer sur les titres du tableau).

Les prototypes sont mappés sur ce qu'on trouve en C avec les types de base. En pratique, je pense que retourner void cause moins de problème (sauf lorsqu'on implémente operator bool pour faire if ((x = foo())) ...).

D'ailleurs, avec les opérateurs, tu ne peux pas vraiment faire ce que tu veux en terme de paramètres ou de retour : tu es presque obligé pour certains de mettre des références.

Non, il n'y a aucune restriction sur le type, on peut mettre n'importe quoi. Il n'y a que operator++(int)/operator--(int) qui demande obligatoirement un int et operator-> qui devient inutilisable si on met n'importe quoi en retour (mais le compilateur n'empêchera pas de le faire). La seule réelle restriction étant le nombre de paramètre.

Pareil pour les opérateurs amis (friend) : cela permet de mettre l'objet pas forcément à gauche mais aussi à droite..

Un opérateur friend n'est pas nécessaire si on n'accède pas aux membres privées, une fonction libre fait l'affaire. Après, il y a un effet assez peu connut de friend qui fait que si le compilateur ne trouve aucun opérateur correspondant ne va pas lister les opérateurs amis si aucun des types en paramètre ne correspond:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct A {
  friend A operator+(const A&, const A&) { return {}; }
};
inline A operator-(const A&, const A&) { return {}; }
 
class B {};
 
int main() {
  B() + 1; // operator+ non listé
  B() - 1; // operator- listé
}

Code :

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

1
2
3
4
5
6
7
8
9
10
test.cpp:9:7: error: invalid operands to binary expression ('B' and 'int')
    9 |   B() + 1; // operator+ non listé
      |   ~~~ ^ ~
test.cpp:10:7: error: invalid operands to binary expression ('B' and 'int')
   10 |   B() - 1; // operator- listé
      |   ~~~ ^ ~
test.cpp:4:10: note: candidate function not viable: no known conversion from 'B' to 'const A' for 1st argument
    4 | inline A operator-(const A&, const A&) { return {}; }
      |          ^         ~~~~~~~~
2 errors generated.