Pourquoi devrais-je utiliser les variables de référence à tous?

Comme mon premier langage de programmation, j'ai appris le Java, mais depuis que j'ai changé d'Université, je suis en train d'apprendre le C++.

Venant de Java et de l'apprentissage des bases du C++, j'ai lu à propos des références et des valeurs de référence. Et comment dangereux, ils peuvent être, et comment être prudent avec eux et ainsi de suite.

Alors dans ma tête, se pose une question simple:
Pourquoi m'embêter à utiliser ce genre de compliqué, et donc potentiellement qui causent des problèmes, des trucs?

Est en quelque sorte la peine, ou tout simplement une relique de l'époque où la RAM est à propos de 64 MO de gros?

Depuis beaucoup de réponses ont mentionné des pointeurs: ce concept est clairement à partir de l'âge de pierre, à mon humble avis. Sauf pour la haute performance de calcul, je ne le touche même pas ce genre de choses.

Ils sont moins dangereux que des pointeurs.
Ce que vous devriez vous poser est plutôt: Maintenant que j'ai des références, pourquoi ai-je besoin de pointeurs? (au passage, les références et les pointeurs intelligents sont plus comme leur Java homologues que les pointeurs).
Outre l'appel par valeur, vous n'avez que des références en java.
Pouvez-vous nous donner un exemple de l'endroit où vous pensez qu'une référence est une mauvaise idée, tandis que vous pensez à quelque chose d'autre (et dire ce) est le meilleur?
Essayez d'apprendre le C++ à travers un filtre de Java compréhension est une mauvaise idée. Essayez d'oublier tout ce que vous savez à propos de Java. Vous ne pouvez pas apprécier que Java est de prêter à confusion, à glisser dans les pointeurs lors du passage des objets. En C++, tout est transparent.

OriginalL'auteur kwoebber | 2012-10-04

  1. 8

    Le problème n'est pas lié à des références de lui-même.

    Le problème est qu'en C++, la durée de vie des objets est gérée différemment qu'en Java ou d'autres environnements d'exécution que l'utilisation d'un ramasse-miettes. C++ n'est pas standard intégré dans le collecteur d'ordures. Objet C++ durée de vie peut être automatique (à l'intérieur de locaux ou étendue globale) ou manuel (explicitement attribuées/libéré dans le tas).

    Une référence C++ est juste un simple alias pour un objet. Elle ne sait rien à propos de la durée de vie des objets (pour des raisons d'efficacité). Le programmeur doit s'en soucier. Une exception est le cas spécial où la référence est lié à un objet temporaire; dans ce cas, la durée de vie de la temporaire est étendu à toute la vie de la limite de référence. Les détails sont ici.

    Les références sont une partie importante de C++ concepts de base et vous ne pouvez pas éviter de les utiliser pour 90% des tâches. Sinon, vous devez utiliser des pointeurs, ce qui est encore pire 🙂

    E. g., lorsque vous avez besoin de passer de l'objet comme argument de fonction par référence au lieu de en valeur vous pouvez utiliser des références:

    void f(A copyOfObj);       //Passed by value, f receives copy of passed A instance
void f(A& refToObj);       //Passed by ref, f receives passed A instance itself, modifiable
void f(const A& refToObj); //Passed by const ref, f receives passed A instance itself, non modifiable
    Est-il plus efficace d'utiliser des références rather que value?
    dans la plupart des cas, oui. Objet de passage par valeur conduira à faire une copie d'objet qui peut être coûteux dans le cas des objets de grande taille et/ou de non-trivial copie d'objet ctor/opérateur d'affectation. Objet de passage par référence conduira à la copie du pointeur.
    Ne connaît pas la durée de vie... à moins qu'il prolonge la durée de vie.

    OriginalL'auteur Rost

  2. 5

    Si vous passer de grands objets en fonction de paramètres par valeur, il pourrait y avoir une véritable chute des performances qui est résolu en passant en références. Aussi, vous pouvez modifier les objets à l'intérieur des fonctions si vous passez par référence et non par valeur.

    Découvrez ces? cplusplus.com/forum/beginner/3958 stackoverflow.com/questions/377529/...
    Et cpp-next.com/archive/2009/08/want-speed-pass-by-value

    OriginalL'auteur SurvivalMachine

  3. 5

    Une référence est un pointeur avec des restrictions. Une référence est un moyen d'accéder à un objet, mais n'est pas l'objet lui-même. Si elle fait sens pour que votre code à l'utilisation de ces restrictions, puis à l'aide d'une référence au lieu d'un pointeur permet au compilateur de vous avertir accidentellement les enfreindre.

    OriginalL'auteur robrochta

  4. 3

    Que vous venez de Java, j'imagine que vous avez des problèmes avec beaucoup de dangereux trucs que C/C++ vous permet de le faire. À mon avis, la différence est ici:

    • C/C++ vous permet de faire beaucoup de puissant et dangereux choses. Vous pouvez faire beaucoup de choses, mais aussi de tirer dans la jambe
    • Java limite ce que vous pouvez faire au nom de la sécurité

    Ce que vous n'aimez pas ("pointeurs/références sont dangereux") est exactement ce que j'aime ("il me permet de faire beaucoup de choses, et si je le rate c'est de ma faute") à propos de C++. C'est une question de langage de programmation goût, à mon avis.

    Références ont été faites pour éviter certains dangers de pointeurs, mais d'un autre côté, même les pointeurs ont encore utilise en outre l'évident d'accès simple et rapide des trucs. Par exemple, disons que vous avez un objet de bas niveau qui fait un travail utile, et est partagé entre plus d'un haut niveau des objets. Il peut être partagé, pour diverses raisons (par exemple, il met à jour l'état interne chaque fois qu'il fait un travail utile si la copie n'est pas une option).

    class HL{
    private:
    LL &object;

    public:
    HL(LL &obj){
        object = obj; //initialization of reference
    }
    //a no-argument constructor is not possible because you HAVE to
    //initialize the reference at object-creation (or you could initialize
    //it to a dummy static object of type LL, but that's a mess)
    void some_routine(){
        ....
        object.useful_work();
        ...
    }
}

    À l'aide de références dans ce cas applique l'initialisation de l'intérieur object. Si, d'autre part, la fonctionnalité de l'objet fournit est juste facultatif pour la qualité de l'objet, que le pointeur est un chemin à parcourir:

    class HL{
    private:
    LL *object;

    public:
    HL(LL &obj){
        object = &obj; //initialization of reference
    }
    HL(){} //no-argument constructor possible
    void some_routine(){
        ....
        if (object != NULL)
           object->useful_work();
        ...
    }
}

    Aussi, que pour l'utilisation de l'appel par référence, qui est le plus utile quand vous êtes en passant une grosse structure à une fonction, par exemple,vector<int>. 

    void function(vector <int> a); //call by value, vector copied every time
void function(vector <int> &a); //call by reference, you can modify
                                //the vector in the function
void function(const vector <int> &a); //if you don't want to be able to modify
                                      //it, you can add const for "protection"

    OriginalL'auteur penelope

  5. 2

    La vraie question est "pourquoi utiliser des références à la place des pointeurs".

    Je n'ai pas tout compris encore. Actuellement, je utiliser des références

    • parce que vous ne pouvez pas céder à eux. Pire des cas, cela ne signifie rien pour le compilateur, mais il y a une chance que le compilateur peut faire usage de cette connaissance.

    • souvent, quand je veux retourner un pointeur qui existe toujours, ou pour indiquer qu'un paramètre est obligatoire et ne peut pas être un nullptr (il n'est pas null référence). Ce n'est pas une règle absolue; parfois une réelle pointeur se sent plus naturel.

    • quand les choses il suffit de demander pour plus de références, comme la surcharge de l'opérateur.

    En général, j'arrive à la fin à l'aide d'un grand nombre de références, car je ne veulent généralement pas à copier des objets, sauf si j'ai vraiment besoin d'une copie réelle, et les références souvent des de travail.

    +1 pour indiquer qu'un paramètre est requis et indiquant que l'objet retourné ne peut pas être null.

    OriginalL'auteur Christian Stieber

  6. 1

    Références faites appel par référence plus facile, puisque l'appelant n'a pas à utiliser le & de l'opérateur lorsque le passinng un objet.

    Comme ceci:

    MyObject ob;

void foo_ref(MyObject& o){ ...}
void foo_ptr(Myobject* o){ ...}

//call

foo_ref(ob);
foo_ptr(&ob);

    En outre, ils permettent l'initialisation des pointeurs dans une fonction:

    MyObject* ob = nullptr;
MySubject* sub = nullptr;

void foo_init(MyObject *& o, MySubject *& s) {

   o = new MyObject;
   s = new MySubject;
}

//call

foo_init(ob, sub);

    Sans la référence de pointeur cet exemple ne travaillons qu'avec des pointeurs de pointeurs, du code look terrible, que vous auriez à derefernce chaque argument premier

    MyObject* ob = nullptr;
MySubject* sub = nullptr;

void foo_init(MyObject ** o, MySubject ** s) {

   *o = new MyObject;
   *s = new MySubject;
}

//call

foo_init(&ob, &sub);
    Les références faites appel par référence possible, parce que vous ne pouvez pas prendre l'adresse de l'arbitraire d'un objet afin de le transmettre à une fonction.

    OriginalL'auteur TeaOverflow

  7. 1

    Les plus fréquentes que l'utilisation de références est d'éviter un coûteux copie en profondeur;
    par défaut, le C++ a une valeur sémantique, et si vous écrivez quelque chose comme:

    void f( std::vector<double> d );

    L'ensemble du vecteur sera copié à chaque fois que vous appelez f. Si vous écrivez
    quelque chose comme:

    void f( std::vector<double> const& d );

    Un seul endroit où cela est particulièrement important, c'est lors de la définition d'un constructeur de copie. Si vous deviez écrire:

    MyType( MyType other );

    vous vous retrouvez avec une récursion infinie puisque le compilateur
    appeler le constructeur de copie pour copier l'argument de ce constructeur. (En fait, le compilateur acceptera seulement un constructeur
    qui prend une référence pour le constructeur de copie, précisément pour éviter ce
    problème.)

    À l'extérieur de constructeurs, c'est vraiment une optimisation et pourrait être
    considéré comme l'optimisation prématurée. Dans la pratique, toutefois, la presque
    convention universelle est de passer de la classe de types par référence const,
    plutôt que par valeur.

    Références peuvent également être utilisés comme paramètres de sortie; par rapport à un pointeur,
    ils ont l'avantage qu'ils ne peuvent pas être null.

    Les références peuvent également être utilisés pour fournir une "fenêtre" dans la classe de données.
    L'exemple classique est la surcharge de operator[] dans std::vector;
    elle renvoie une référence de sorte que vous pouvez modifier, prendre l'adresse de l', etc.
    la réelle de l'élément dans le tableau.

    Les autres que comme des paramètres et valeurs de retour, dans le cas ci-dessus,
    les références sont assez rares. Si vous l'utiliser comme un membre de la classe, pour
    exemple, vous devez être conscient que vous ne pouvez pas donner à la classe classique
    affectation de la sémantique. (Ce n'est pas un problème si la classe n'est pas
    soutien affectation). Comme une variable globale, ils pourraient être utilisés pour masquer
    la mise en œuvre de ce qui est mentionné, mais c'est extrêmement
    rare. Comme une variable locale, sur la seule utilisation que je sais, c'est pour mettre en cache les
    les résultats d'une autre expression qui renvoie une référence: par exemple, si
    Je suis accès à someMap[aKey] un grand nombre de fois dans un court laps de bloc
    de code, il est logique d'écrire:

    ValueType& element = someMap[aKey];

    au début, et l'utilisation element après. (Notez que cela ne fait qu'
    sens parce que someMap[aKey] renvoie une référence.)

    OriginalL'auteur James Kanze

  8. 0

    Par exemple parce qu'ils sont en train de vous forcer à initialze, ce qui les rend moins dangereux

    Cela semble plus comme un commentaire..

    OriginalL'auteur ISTB