Discussion :

[hostyle]

Bonjour voila je suis novice en C++ et le chapitre sur les pointeur et les référence m'embrouille l'esprit!
J'explique mon problème:

un pointeur contient l'adresse d'un autre objet,
les référence permettent de récupérer l'adresse d'un objet

mais je ne comprend pas l'exemple suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int i=0;      /* Déclare une variable entière. */
int *pi;      /* Déclare un pointeur sur un entier. */
pi=&i;        /* Initialise le pointeur avec l'adresse de cette
                variable. */
*pi = *pi+1;  /* Effectue un calcul sur la variable pointée par pi,
                 c'est-à-dire sur i lui-même, puisque pi contient
                 l'adresse de i. */
 
              /* À ce stade, i ne vaut plus 0, mais 1. */

donc cet exemple a quoi correspond pi?

et que signifie:


int i=0;
int *pi=&i;
*pi=*pi+1;

dans cet exemple i vaut 1 mais on a dit que le pointeur *pi contenait l'adresse de i mais l'adresse de i ne vaut pas 0 non?

[koala01]

Salut,

Attention, tu te trompes déjà:

Un pointeur représente, effectivement, l'adresse à laquelle on trouvera une variable, mais une référence est... l'alias d'une variable.

Il y a deux différences principales entre un pointeur et une référence:

1. Une référence assure l'existence de la variable référencée, alors qu'un pointeur peut ne pointer sur rien
2. Une référence assure plus facilement la constante de la variable référencée qu'un pointeur

Ta confusion vient du fait que les symboles utilisés pour déclarer une référence et celui de l'opérateur "address of" (qui permet de récupérer l'adresse d'une variable) sont identiques.

Pour te permettre de faire la différence entre les deux, tu peux te dire que l'esperluette ' & ' est:

• utilisée pour représenter une référence lorsqu'elle est utilisée pour une déclaration (de variable ou d'argument). Elle est donc précédée d'un nom de type et d'un "CV-qualifier" éventuel et suivie (ou non) du nom de la variable ou de l'argument
• utilisée pour représenter l'opérateur "address of" lorsqu'elle est utilisée dans le cadre d'une affectation ou du passage... de l'adresse d'une variable comme argument. Elle apparait donc soit juste après un symbole d'égalité soit dans un appel de fonction.

Pour que tu puisse comprendre, voici quelques lignes de code, et les explications qui vont bien.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Type var; // déclaration d'une variable
Type * ptr; // déclaration d'un pointeur du même type que la variable 
// l' & est précédé d'un signe = : c'est l'opérateur address of
ptr = & var;
// l'& est dans la partie "déclaration" : c'est une référence
Type & ref = var; 
// l'& est précédée du signe = : c'est l'opéateur address of
if(ptr== & var) 
// une déclaration de fonction (ou sa signature): c'est une référence
void foo(Type /* const */ & /* laref */);
// on est dans le cadre d'un appel de fonction: c'est l'opérateur address of
bar(&var);

[Aleph69]

Bonjour,

donc cet exemple a quoi correspond pi?

Dans ton exemple, pi représente un "pointeur sur int".

et que signifie:

int i=0;
int *pi=&i;
*pi=*pi+1;

Cela signifie que pi va "pointer" sur i.
Il y a une petite subtilité à la dernière ligne : une fois un pointeur déclaré, on utilise l'opérateur * pour accéder à l'adresse vers laquelle il pointe.
Ainsi, à la ligne

Code :

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

1
2
 
*pi=*pi+1;

on accède à l'adresse vers laquelle pointe pi, c'est-à-dire celle de i, et on procède à une bête incrémentation (i=i+1).

C'est la raison pour laquelle i vaut 1 à la fin.

[Chessmaster1966]

Comme l'a dit Koala01 Il ne faut pas confondre :

1) &, représente l'opérateur d'adressage c'est à dire qu'il retourne l'adresse de la variable qu'il a en operande (&i)

2) & sert également à créer un alias. Un alias c'est tout simplement un autre nom pour une variable (en quelque sorte un surnom).

Donc dans l'exemple que tu as donné :


int i = 0;
Ce "statement" défini un objet mémoire initialisé à la valeur 0 et portant le nom de i.

int *pi = &i;
Ce "statement" défini un objet mémoire initialisé avec l'adresse mémoire de l'objet i et porte le nom pi.

L'étoile est l'opérateur de déréférencement mais ici dans ce "statement" il sert à définir un pointeur.

Donc, dans ce "statement" le compilateur va d'abort récupérer l'adresse de l'objet i puis l'a placer dans l'objet pi.

A ce stade le pointeur pi ne contient pas la valeur 0 mais l'adresse de la variable i. Pour pouvoir manipuler la valeur de i via le pointeur pi il faut utiliser l'opérateur de déréférencement (*) de la façon que tu as faite :
*pi = *pi + 1 équivaut à ++i.

Si tu n'utilise pas l'opérateur de déréférencement comme ceci :
pi = pi + 1
alors tu passe à l'adresse suivante donc pi pointe sur n'importe quoi et te causera bien des soucis.

Pour l'alias c'est une toute autre histoire.
Une variable qui est un alias d'un autre objet est un surnom et doit obligatoirement être initialiser au moment ou l'on le déclare.
Attention ce n'est pas vraiment une variable mais un autre nom qui se déclare comme une variable.

int i = 1200;
int &ai = i;

ai = 2000; //Equivaut à i = 2000, on utilise son surnom (ai n'est pas un objet mémoire à part entière mais l'objet mémoire nommé i).

Comme tu peux le voir ce n'est pas la même chose.

Conclusion :
1) un pointeur ne se déclare pas comme un alias et inversement.
2) un pointeur peut pointer sur n'importe quel objet mémoire ce n'est pas le cas pour un alias.
3) un pointeur peut être simplement déclarer sans être initialisé alors qu'un alias ne le peut pas.

Il faut si possible utiliser des alias plutôt que des pointeurs quand cela est possible. Les alias
présentent bien plus de sécurité qu'un pointeur.

[esteban]

Bonjour à tous,

je ressors ce topic car moi aussi j'ai du mal à me représenter la différence concrète qu'il y a entre une référence et un pointeur.

Par exemple le code ci dessous :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void fonction(int i, std::string s, Objet *o) {
   //bla bla bla
}
 
void main() {
    int a = 0;
    std::string t = "ma string;"
    Objet *p = new Objet;
}

Si j'ai bien compris l'avantage de la référence sur le pointeur c'est que la référence permettrait d'avoir la certitude que l'adresse vaut quelque chose de cohérent. Par contre laquelle des 2 syntaxes est une référence :

Code :

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

1
2
3
 
Objet o;
Objet & o;

Pourquoi dans certains cas (QT par exemple) les objets sont initialisés comme ceci :

Code :

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

1
2
 
Objet o("test");

Est-ce que cela correspond à une valeur, un pointeur ou une référence... ou autre ?

Enfin (pour le moment), jusqu'à présent j'écris mes fonctions pour qu'elles recoivent un pointeur :

Code :

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

1
2
 
void fonction(Objet *o);

quel avantage il y aurait à écrire :

Code :

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

1
2
 
void fonction(Objet & o);

?

Ca doit vous sembler bateau comme question mais toutes ces syntaxes différentes rendent selon moi le langage confus et les explications et cours trouvés sur internet le sont encore plus...

Merci
Tristan

[Firwen]

Est-ce que cela correspond à une valeur, un pointeur ou une référence... ou autre ?

Techniquement une chaine de caractere constante comme dans ton example : "test" est un "const char *".

Ceci dit, dans le cas de Qt, c'est un peu particulier. Certaines methodes exigent un type QString qui est automatiquement construit à partir de ton "const char *" http://qt.developpez.com/doc/latest/qstring.html

quel avantage il y aurait à écrire :
Code :


void fonction(Objet & o);


?

ça apporte entre autres une certaine sureté de typage.

Lorsque l'on passe une variable par pointeur, si le pointeur passé est nul ou qu'il n'est pas initialisé, des comportements non-souhaités arrivent.
Généralement, un magnifique SEGfault qui blesse profondemment ton égo

Lorsque l'on passe une variable par reference, ces problèmes ne se posent pas ( dans la théorie :p )

[Médinoc]

Le problème de la définition "alias", c'est qu'on peut presque la jeter par la fenêtre dès qu'une référence est en paramètre de fonction; à ce moment là, c'est peu de chose de plus (mais un peu quand même) qu'un pointeur déguisé.

Mais il reste certaines choses que les références assurent:
Une référence n'est jamais nulle tant qu'on ne joue pas avec des pointeurs autour. Tu n'as pas à tester la nullité d'une référence; tu peux, au pire, mettre un assert() dessus et c'est tout, et si l'assertion pète, c'est le maniement des pointeurs qu'il faut corriger, jamais la référence elle-même.