Quand passer par référence et quand passer par pointeur en C ++?

Question

Situations Courantes:

1. En passant std::string à une fonction foo(std::string*) ou foo(std::string&);
2. En passant tr1::shared_ptr à une fonction foo(tr1::shared_ptr* ptr) ou foo(tr1::shared_ptr& ptr);

En général, ce qui est une bonne pratique. J'ai toujours confondu. Au premier abord, en passant tout ce que la référence semble cohérent, mais il n'est pas possible de passer dans les Littéraux comme des références ou des valeurs Null comme des références.

De la même façon, tout comme les pointeurs semble bon, mais ayant ensuite j'ai à vous inquiéter que les pointeurs peuvent être pointant vers NULLE et de vérifier ces conditions dans le début de cette fonction.

Pensez-vous que l'extrait de code suivant est la bonne?

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <tr1/memory>
#include <algorithm>
using namespace std;
using namespace std::tr1;

int main(){
        map<string, shared_ptr<vector<string> > > adjacencyMap;
        vector<string>* myFriends = new vector<string>();
        myFriends->push_back(string("a"));
        myFriends->push_back(string("v"));
        myFriends->push_back(string("g"));
        adjacencyMap["s"] = shared_ptr<vector<string> >(myFriends);
        return 0;
}

Merci Ajay

Answer 1

Les références sont plus faciles pour obtenir le droit.

Est votre problème avec les littéraux que vous n'utilisez pas const références? Vous ne pouvez pas lier un temporaire (produit par un littéral) à un non-const de référence, parce qu'il n'a pas de sens pour la modifier. Vous pouvez lier l'un à l'const référence.

En particulier, lors du passage d'un argument à une fonction, et la fonction ne va pas changer, et ce n'est pas un type, passer par référence const. Il fonctionne de la même que le passage par valeur, sauf qu'il n'a pas besoin d'un constructeur de copie d'appel.

Les pointeurs sont utiles, car ils ont une garantie de valeur non valide, vous pouvez tester. Parfois, ce n'est pas pertinent, et c'est parfois très important. Bien sûr, vous ne pouvez pas généralement passer un littéral par pointeur, sauf dans le cas d'une chaîne de caractères littérale), il ne l'est déjà.

Certaines normes de codage de dire que rien ne doit jamais être transmis par des non-const de référence, car il ne fournit aucune indication sur le point d'appel que l'argument peut être modifié par la fonction. Dans ce cas, il vous sera nécessaire de passer par un pointeur. Je ne suis pas favorable à cette mesure, notamment comme outils de programmation plus facile et plus facile d'obtenir la signature de la fonction, de sorte que vous pouvez voir si une fonction peut changer un argument. Cependant, lorsque l'on travaille dans un groupe ou une entreprise, le style, la cohérence est plus important que n'importe quel individu de l'élément de style.

Answer 2

Une bonne règle d'or: "Utilisez des références quand vous le pouvez et des pointeurs quand vous devez".

Answer 3

Probablement pas une réponse à la question. Juste embrasse.

 int main()
{
        multimap<string, string> adjacencyMap;
        adjacencyMap.insert(std::make_pair("s", "a"));
        adjacencyMap.insert(std::make_pair("s", "v"));
        adjacencyMap.insert(std::make_pair("s", "g"));
        return 0;
}
 

Answer 4

Je ne comprends vraiment pas pourquoi vous avez eu tous ces ennuis:

 std::map < std::string, std::vector<std::string> > adjacencyMap;
std::vector<std::string>& sFriends = adjacencyMap["s"];
sFriends.push_back("a");
sFriends.push_back("v");
sFriends.push_back("g");
 

Pourquoi vous mêlez-vous de shared_ptr ici? La situation ne l'exige certainement pas!

Answer 5

Vous pouvez parcourir http://www.cplusplus.com/forum/beginner/3958/ pour quelques pistes de réflexion. Utile également: http://www.velocityreviews.com/forums/t284603-pointers-vs-references-a-question-on-style.html

Je suppose qu'il n'y a pas de "bonne" réponse. Vous avez besoin de poids avantages et les inconvénients de chaque approche en tenant compte du contexte spécifique de votre projet.

Personnellement, je préfère les références, mais je vous conseille de toute façon de lire ces posts et muse à ce sujet.