C'est un peu subjectif je pense; Je ne sais pas si l'opinion sera unanime (j'ai vu beaucoup d'extraits de code où les références sont retournées).

Selon un commentaire sur cette question que je viens de poser, concernant l'initialisation des références , renvoyer une référence peut être mauvais car, [si je comprends bien], il est plus facile de manquer de la supprimer, ce qui peut entraîner des fuites de mémoire.

Cela m'inquiète, car j'ai suivi des exemples (à moins que j'imagine des choses) et l'ai fait à plusieurs endroits ... Ai-je mal compris? Est-ce mal? Si oui, à quel point le mal?

Je pense qu'en raison de mon mélange de pointeurs et de références, combiné au fait que je suis nouveau en C ++ et à une confusion totale sur ce qu'il faut utiliser quand, mes applications doivent être un enfer de fuite de mémoire ...

De plus, je comprends que l'utilisation de pointeurs intelligents / partagés est généralement acceptée comme le meilleur moyen d'éviter les fuites de mémoire.

En général, le renvoi d'une référence est parfaitement normal et se produit tout le temps.

Si tu veux dire:

int& getInt() {
    int i;
    return i;  // DON'T DO THIS.
}

C'est toutes sortes de mal. La pile allouée idisparaîtra et vous ne faites référence à rien. C'est aussi mal:

int& getInt() {
    int* i = new int;
    return *i;  // DON'T DO THIS.
}

Parce que maintenant, le client doit finalement faire l'étrange:

int& myInt = getInt(); // note the &, we cannot lose this reference!
delete &myInt;         // must delete...totally weird and  evil

int oops = getInt(); 
delete &oops; // undefined behavior, we're wrongly deleting a copy, not the original

Notez que les références rvalue ne sont encore que des références, donc toutes les applications malveillantes restent les mêmes.

Si vous souhaitez allouer quelque chose qui dépasse la portée de la fonction, utilisez un pointeur intelligent (ou en général, un conteneur):

std::unique_ptr<int> getInt() {
    return std::make_unique<int>(0);
}

Et maintenant, le client stocke un pointeur intelligent:

std::unique_ptr<int> x = getInt();

Les références sont également acceptables pour accéder à des éléments dont vous savez que la durée de vie est maintenue ouverte à un niveau supérieur, par exemple:

struct immutableint {
    immutableint(int i) : i_(i) {}

    const int& get() const { return i_; }
private:
    int i_;
};

Ici, nous savons qu'il est correct de renvoyer une référence i_car tout ce qui nous appelle gère la durée de vie de l'instance de classe, il i_vivra donc au moins aussi longtemps.

Et bien sûr, il n'y a rien de mal à simplement:

int getInt() {
   return 0;
}

Si la durée de vie doit être laissée à l'appelant et que vous calculez simplement la valeur.

Résumé: vous pouvez renvoyer une référence si la durée de vie de l'objet ne se termine pas après l'appel.

Non, non, mille fois non.

Ce qui est mal, c'est de faire référence à un objet alloué dynamiquement et de perdre le pointeur d'origine. Lorsque vous newun objet, vous assumez l'obligation d'avoir une garantie delete.

Mais jetez un œil à, par exemple, operator<<qui doit renvoyer une référence, ou

cout << "foo" << "bar" << "bletch" << endl ;

ne fonctionnera pas.

Vous devez renvoyer une référence à un objet existant qui ne disparaît pas immédiatement et où vous ne prévoyez aucun transfert de propriété.

Ne renvoyez jamais une référence à une variable locale ou à une telle, car elle ne sera pas là pour être référencée.

Vous pouvez renvoyer une référence à quelque chose d'indépendant de la fonction, que vous ne vous attendez pas à ce que la fonction appelante prenne la responsabilité de la suppression. C'est le cas pour la operator[]fonction typique .

Si vous créez quelque chose, vous devez renvoyer une valeur ou un pointeur (normal ou intelligent). Vous pouvez renvoyer une valeur librement, car elle va dans une variable ou une expression dans la fonction appelante. Ne renvoyez jamais un pointeur sur une variable locale, car il disparaîtra.

Je ne trouve pas les réponses satisfaisantes, je vais donc ajouter mes deux cents.

Analysons les cas suivants:

Utilisation erronée

int& getInt()
{
    int x = 4;
    return x;
}

C'est évidemment une erreur

int& x = getInt(); // will refer to garbage

Utilisation avec des variables statiques

int& getInt()
{
   static int x = 4;
   return x;
}

C'est vrai, car les variables statiques existent tout au long de la durée de vie d'un programme.

int& x = getInt(); // valid reference, x = 4

Ceci est également assez courant lors de l'implémentation d'un modèle Singleton

Class Singleton
{
    public:
        static Singleton& instance()
        {
            static Singleton instance;
            return instance;
        };

        void printHello()
        {
             printf("Hello");
        };

}

Usage:

 Singleton& my_sing = Singleton::instance(); // Valid Singleton instance
 my_sing.printHello();  // "Hello"

Les opérateurs

Les conteneurs de bibliothèque standard dépendent fortement de l'utilisation d'opérateurs qui renvoient une référence, par exemple

T & operator*();

peut être utilisé dans les cas suivants

std::vector<int> x = {1, 2, 3}; // create vector with 3 elements
std::vector<int>::iterator iter = x.begin(); // iterator points to first element (1)
*iter = 2; // modify first element, x = {2, 2, 3} now

Accès rapide aux données internes

Il y a des moments où & peut être utilisé pour un accès rapide aux données internes

Class Container
{
    private:
        std::vector<int> m_data;

    public:
        std::vector<int>& data()
        {
             return m_data;
        }
}

avec utilisation:

Container cont;
cont.data().push_back(1); // appends element to std::vector<int>
cont.data()[0] // 1

CEPENDANT, cela peut conduire à un piège comme celui-ci:

Container* cont = new Container;
std::vector<int>& cont_data = cont->data();
cont_data.push_back(1);
delete cont; // This is bad, because we still have a dangling reference to its internal data!
cont_data[0]; // dangling reference!

Ce n'est pas mal. Comme beaucoup de choses en C ++, c'est bien s'il est utilisé correctement, mais il y a de nombreux pièges que vous devez savoir lorsque vous l'utilisez (comme retourner une référence à une variable locale).

Il y a de bonnes choses qui peuvent être réalisées avec cela (comme map [name] = "hello world")

"renvoyer une référence est mauvais parce que, simplement [si je comprends bien], il est plus facile de manquer de la supprimer"

Pas vrai. Le renvoi d'une référence n'implique pas de sémantique de propriété. C'est juste parce que vous faites cela:

Value& v = thing->getTheValue();

... ne signifie pas que vous possédez maintenant la mémoire mentionnée par v;

Cependant, c'est un code horrible:

int& getTheValue()
{
   return *new int;
}

Si vous faites quelque chose comme ça parce que "vous n'avez pas besoin d'un pointeur sur cette instance" alors: 1) juste déréférencer le pointeur si vous avez besoin d'une référence, et 2) vous aurez éventuellement besoin du pointeur, car vous devez faire correspondre un nouveau avec une suppression, et vous avez besoin d'un pointeur pour appeler la suppression.

Il y a deux cas:

• référence const - bonne idée, parfois, en particulier pour les objets lourds ou les classes proxy, optimisation du compilateur

• référence non constante - mauvaise idée, parfois, rompt les encapsulations

Les deux partagent le même problème - peut potentiellement pointer vers un objet détruit ...

Je recommanderais d'utiliser des pointeurs intelligents pour de nombreuses situations où vous devez renvoyer une référence / un pointeur.

Notez également ce qui suit:

Il existe une règle formelle - la norme C ++ (section 13.3.3.1.4 si vous êtes intéressé) stipule qu'un temporaire ne peut être lié qu'à une référence const - si vous essayez d'utiliser une référence non const, le compilateur doit le signaler comme une erreur.

Non seulement ce n'est pas mal, c'est parfois essentiel. Par exemple, il serait impossible d'implémenter l'opérateur [] de std :: vector sans utiliser une valeur de retour de référence.

Ajout à la réponse acceptée:

struct immutableint {
    immutableint(int i) : i_(i) {}

    const int& get() const { return i_; }
private:
    int i_;
};

Je dirais que cet exemple n'est pas correct et devrait être évité si possible. Pourquoi? Il est très facile de se retrouver avec une référence pendante .

Pour illustrer ce point avec un exemple:

struct Foo
{
    Foo(int i = 42) : boo_(i) {}
    immutableint boo()
    {
        return boo_;
    }  
private:
    immutableint boo_;
};

entrer dans la zone de danger:

Foo foo;
const int& dangling = foo.boo().get(); // dangling reference!

la référence de retour est généralement utilisée dans la surcharge d'opérateur en C ++ pour les objets de grande taille, car le retour d'une valeur nécessite une opération de copie. (en cas de surcharge du pérateur, nous n'utilisons généralement pas le pointeur comme valeur de retour)

Mais la référence de retour peut provoquer un problème d'allocation de mémoire. Dans la mesure où une référence au résultat sera passée hors de la fonction en tant que référence à la valeur de retour, la valeur de retour ne peut pas être une variable automatique.

si vous voulez utiliser le renvoi de référence, vous pouvez utiliser un tampon d'objet statique. par exemple

const max_tmp=5; 
Obj& get_tmp()
{
 static int buf=0;
 static Obj Buf[max_tmp];
  if(buf==max_tmp) buf=0;
  return Buf[buf++];
}
Obj& operator+(const Obj& o1, const Obj& o1)
{
 Obj& res=get_tmp();
 // +operation
  return res;
 }

de cette façon, vous pouvez utiliser le renvoi de référence en toute sécurité.

Mais vous pouvez toujours utiliser le pointeur au lieu de la référence pour renvoyer une valeur dans functiong.

Je pense que l'utilisation de référence comme valeur de retour de la fonction est beaucoup plus simple que d'utiliser le pointeur comme valeur de retour de la fonction. Deuxièmement, il serait toujours sûr d'utiliser une variable statique à laquelle se réfère la valeur de retour.

La meilleure chose est de créer un objet et de le passer comme paramètre de référence / pointeur à une fonction qui alloue cette variable.

Allouer un objet dans la fonction et le renvoyer comme référence ou pointeur (le pointeur est plus sûr cependant) est une mauvaise idée en raison de la libération de mémoire à la fin du bloc fonction.

    Class Set {
    int *ptr;
    int size;

    public: 
    Set(){
     size =0;
         }

     Set(int size) {
      this->size = size;
      ptr = new int [size];
     }

    int& getPtr(int i) {
     return ptr[i];  // bad practice 
     }
  };

La fonction getPtr peut accéder à la mémoire dynamique après la suppression ou même à un objet nul. Ce qui peut provoquer de mauvaises exceptions d'accès. Au lieu de cela, getter et setter doivent être implémentés et leur taille vérifiée avant de revenir.

La fonction comme lvalue (aka, retour de références non const) doit être supprimée de C ++. C'est terriblement peu intuitif. Scott Meyers voulait un min () avec ce comportement.

min(a,b) = 0;  // What???

ce qui n'est pas vraiment une amélioration

setmin (a, b, 0);

Ce dernier est même plus logique.

Je me rends compte que la fonction lvalue est importante pour les flux de style C ++, mais il convient de souligner que les flux de style C ++ sont terribles. Je ne suis pas le seul à penser cela ... si je me souviens, Alexandrescu avait un grand article sur la façon de faire mieux, et je pense que boost a également essayé de créer une meilleure méthode d'E / S sécurisée.

Je suis tombé sur un vrai problème où il était en effet mauvais. Un développeur a essentiellement renvoyé une référence à un objet dans un vecteur. C'était mauvais !!!

Les détails complets sur lesquels j'ai écrit en janvier: http://developer-resource.blogspot.com/2009/01/pros-and-cons-of-returing-references.html

À propos du code horrible:

int& getTheValue()
{
   return *new int;
}

Donc, en effet, le pointeur de mémoire a perdu après le retour. Mais si vous utilisez shared_ptr comme ça:

int& getTheValue()
{
   std::shared_ptr<int> p(new int);
   return *p->get();
}

La mémoire n'est pas perdue après le retour et sera libérée après l'affectation.