Bonjour, quelle est la différence entre ces deux fonctions :

La quelle je dois utiliser ?

void hello(string *name) // Utilise un pointeur
{
    cout << "Hello " << name << endl;
}

void hello(string &name) // Utilise une référence
{
    cout << "Hello " << name << endl;
}

-
Edité par Anonyme 16 juin 2018 à 23:05:54

La troisième :

void hello(const string &name) // Utilise une référence constante
{
    cout << "Hello " << name << endl;
}

OUBLIES les pointeurs nus pour le moment. Règle de base en C++ : les pointeurs sont la dernière solution à envisager.

Salut,

Avant d'aller plus loin, je tiens à préciser que je suis tout à fait d'accord avec gbdivers (mais on est souvent d'accord, il faut dire ) : les pointeurs ne doivent être utilisés que lorsque l'on n'a vraiment pas d'autre choix.

Mais pour répondre à ta question : si on s'amuse à comparer le code binaire qui sera généré par les trois versions proposées (les deux tiennes et celle de gbdivers), il n'y aura absolument aucune différence: un processeur étant bête à bouffer du foin, les seules chose qu'il puisse comprendre lors de l'appel de fonction, c'est qu'on lui transmet une valeur, et, le cas échéant, que cette valeur correspond à l'adresse mémoire à laquelle se trouve la donnée qu'il devra utiliser.

Par contre, un pointeur n'est rien d'autre qu'une donnée numérique entière (généralement non signée) qui représente l'adresse mémoire à laquelle on espère trouver trouver la donnée du type indiqué.

Quand tout se passe correctement, et que le type de la donnée qui se trouve à l'adresse mémoire indiquée correspond au type de donnée que l'on espère trouver à cette adresse, la seule différence au niveau du code est syntaxique : on utilisera -> pour accéder aux différents membres au lieu d'utiliser . .

Par contre, un pointeur peut avoir une valeur qui est "connue pour être invalide" (nullptr). Et si le paramètre de la fonction hello est un pointeur dont la valeur correspond à nullptr, toute tentative visant à "déréférencer" le pointeur (autrement dit : toute tentative d'accéder à "ce qui se trouve" à l'adresse indiquée par le pointeur) finira forcément de manière catastrophique lors de l'exécution.

Ta fonction void hello(string *name) est donc fondamentalement buggée, ne serait-ce que parce que tu ne prend pas en compte le fait que name pourrait tout aussi bien représenter une adresse invalide (nullptr) qu'une adresse à laquelle nous trouverons -- effectivement -- une donnée de type string.

En outre, je te l'ai dit : un pointeur n'est jamais qu'une valeur numérique entière qui représente l'adresse à laquelle se trouve une donnée.

Si l'on est très gentil et que l'on ignore le fait que tu aurais d'assurer avant toute chose que name n'est pas égal à nullptr, le code de cette fonction provoquera l'affichage de... l'adresse mémoire à laquelle nous sommes supposés trouver une donnée de type string

Si tu veux afficher la donnée de type string correctement (et non l'adresse à laquelle elle se trouve), tu dois afficher ... "ce qui est pointé" par ton pointeur name.

Au final, cette fonction pourrait prendre une forme proche de

void hello(string *name) // Utilise un pointeur
{
    if(name)
        cout << "Hello " << *name << endl;
    else
        cout << "sorry, you didn't give me a valid name" <<endl;
}

(ce n'est bien sur qu'un exemple

L'art de faire des réponses compliqués pour dire "ne fais pas ça"

Si tu veux faire plus compliqué, tu peux ajouter qu'un pointeur différent de nullptr n'est pas forcement valide (donc que le code que tu donnes n'est pas forcement valide). Ou que l'on ne sait rien de la propriété (ownership) et donc s'il faut delete name ou pas (et donc que le code que tu donnes produit peut etre une fuite memoire).

Bref, il ne faut pas utiliser les pointeurs.