Discussion :

[Papy214]

Bonjour

Confronté récemment à quelques lignes ce C++ sans y connaître vraiment pas grand-chose, j'ai vu l'utilisation d' & et * que je n'ai pas vraiment comprise.

Ces & étaient positionnés devant des paramètres, devant des noms de variables, limite un peu partout :-(

Exemples:

Code :

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

1
2
3
4
5
 
bool fileCanBeOpen(std::string const & filename)
 
 
result.push_back(coef*(*el));  // Là je me doute que * après coef est la multiplication mais celui avant el ???????

De plus, le & est parfois tout seul et parfois collé à une variable. Tout ça est un peu confus pour moi.

Alors je cherche un site qui m'expliquerait ça façon "les & c++pour les nulls"

A moins qu'une âme charitable prenne le temps de faire ça ici

[Médinoc]

Ah, en fait pour le & tu te heurtes là à deux syntaxes différentes, qui font références à des concepts très différents:

• Dans une expression, le & est lié aux pointeurs, il s'agit de l'opérateur "adresse de". On la voit ici:
  

  Code C++ :

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

  1
  2
  3
  int a; //Déclaration d'un entier
  int *p; //Déclaration d'un pointeur sur entier
  p = &a; //Le pointeur contient maintenant l'adresse de l'entier.

  Cette syntaxe existe aussi bien en C qu'en C++.
• Dans une déclaration, c'est une syntaxe propre au C++, qui déclare une variable comme étant une référence à une autre. Quand on l'utilise pour déclarer des paramètres de fonction (comme dans bool fileCanBeOpen(std::string const & filename)), il s'agit plus ou moins de pointeurs déguisés. Dans l'exemple de fileCanBeOpen(), cela signifie que la chaîne filename est passée par référence à la fonction, c'est-à-dire qu'elle n'est pas recopiée. Le const indique que cette référence ne permet pas de modifier l'objet.

Pour ce qui est de l'astérisque, elle est propre au pointeurs, mais elle aussi a deux significations légèrement différentes selon où elle se trouve:

• Dans une expression, il s'agit de l'opérateur de déréférencement, c'est-à-dire l'opérateur d'accès à la donnée pointée. Si je reprends le code au-dessus et que j'ajoute cette ligne:
  

  Code :

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

  *p = 42;

  L'entier pointé par p (ici, il s'agit de a) va recevoir la valeur 42.
• Dans une déclaration, il indique que la variable qu'on déclare est un pointeur. int *p; déclare la variable p de type "pointeur sur int". Si je déclares un pointeur int const * const p2 = &a;, Je déclares un pointeur qui ne peut pas être modifié, et ne permet pas non-plus de modifier la valeur pointée (mais il permet de la lire).

Note juste pour être complet: Ici, le concept d'opérateur signifie simplement une partie d'une expression qui retourne une valeur; un opérateur prend une ou plusieurs entrées, et retourne une valeur en sortie (qu'on peut ensuite mettre dans une variable, passer en paramètre à une fonction, ou ignorer).

[ternel]

On a plusieurs cours qui inclue un bon chapitre sur les pointeurs (notamment Penser en C++), regarde dans notre section tutoriels.

En résumé:

La mémoire d'un ordinateur est un ensemble d'octets numérotés. Ainsi, sur un ordinateur 64 bits, ces numéros vont de 0 à 2 puissance 64 (c'est à dire "beaucoup")
Le numéro d'un octet est appelé son adresse.

Une adresse est une valeur comme une autre, elle peut se stocker dans une variable.
Une telle variable est appelée pointeur.

Une spécificité des pointeurs, c'est que les adresses d'int ne sont pas compatibles avec celles de char ni celles de double (etc).

Si p est un pointeur d'entier et i est un entier, alors:

• p est le nom d'un bloc mémoire pouvant contenir un pointeur d'entier
• la valeur de p est une adresse d'entier
• i est le nom d'un bloc mémoire pouvant contenir un entier
• la valeur de i est un entier
• &i est l'adresse du bloc mémoire nommé i
• *p est la valeur de l'entier contenu dans le bloc mémoire désigné par l'adresse contenue dans p
• &p est l'adresse du bloc mémoire nommé p (c'est à dire l'adresse d'un bloc mémoire qui contient l'adresse d'un bloc mémoire qui contient un entier), c'est une valeur pour un pointeur de pointeur d'entier.
• p = &i signifie que le programme met l'adresse de i dans la variable p.
• *p = 2 signifie que le programme met 2 dans le bloc mémoire désigné par l'adresse contenue dans p

Pour t'aider, considère que l'étoile signifie toujours "ce que désigne"
Ainsi *p = 2 se lirait "ce que désigne p reçoit la valeur 2".

En C++, il y a une subtilité supplémentaire: les références
il est possible de déclarer des variables comme étant "un autre nom pour" une autre, et c'est écrit avec un & dans la déclaration.

ainsi:

• int * p, q signifie soient de type int "ce que désigne p", et q (attention au piège, l'étoile porte sur p uniquement, pas sur int, donc pas sur q.)
• int &r = q signifie soit de type int r un autre nom de q. à partir de maintenant, r et q sont le même bloc mémoire.

en dehors d'une déclaration de variable, le & est l'opérateur qui permet d'obtenir l'adresse de ce à quoi il s'applique (ou dans de rare cas, l'opérateur de conjonction (and) bit à bit)

Un pointeur sert (normalement) quand on veut faire des choses dynamiques, que le programme n'est pas vraiment capable de déterminer à la compilation:

• réservation de blocs de mémoire de taille inconnue à la compilation
• pointeur de fonction pour choisir à l'exécution quelle fonction exécuter
• d'autres choses, comme les listes chainées ou les graphes

En règle générale, les pointeurs posent beaucoup de problème technique, et leur usage en C++ est de plus en plus rare, les classes de la STL comme std::vector ou std::string gérant la très grande majorité des cas.

edit: doublé par médinoc

[Pyramidev]

Tout a été dit.

Si je reprends le code au-dessus et que j'ajoute cette ligne:

Code :

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

p* = 42;

L'entier pointé par p (ici, il s'agit de a) va recevoir la valeur 42.

Faute de frappe :

Code :

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

*p = 42;

[Médinoc]

Oups, corrigé.

[Papy214]

Merci pour vos réponses que j'étudierai mieux dès ce w-e.

Je reviendrai surement pour des précisions :-)

[foetus]

Ensemble d'octets numérotés. Ainsi, sur un ordinateur 64 bits, ces numéros vont de 0 à 2 puissance 64 (c'est à dire "beaucoup")
Le numéro d'un octet est appelé son adresse.

Je chipote : vont de 0 à 2 puissance 48 (de mémoire, la mienne ) (c'est à dire "moins beaucoup")

[Papy214]

Bon, si je reprends
& peut être utilisé dans les paramètres d'une fonction et dans ce cas il n'est pas accolé au nom du paramètre mais placé entre le type et le paramètre
Le paramètre ne peut pas être modifié dans la fonction
Si const n'est pas ajouté, on pourrait modifier le contenu et la valeur serait modifiée en sortie de fonction
Si on ne met pas de &, on peut modifier le contenu dans la fonction mais au retour de l'appelant, le contenu a gardé sa valeur initiale

Dans du code, ça renvoie une adresse et c'est donc l'équivalent Pascal de @


Pour * , ça désigne un pointeur.


Mais dans mon "monde" Delphi, un pointeur est une adresse mémoire.
Si j'utilise un type pointeur comme paramètre d'une fonction, ça veut dire que je peux modifier le contenu de l'adresse mémoire pointée.


Est-ce qu'on peut utiliser un type pointeur comme type de paramètre dans une déclaration de fonction ??

[Bousk]

& dans la déclaration d'une variable est pour une référence, qui est un allias sur une variable

Est-ce qu'on peut utiliser un type pointeur comme type de paramètre dans une déclaration de fonction ??

Bah... oui.

Mais dans mon "monde" Delphi, un pointeur est une adresse mémoire.
Si j'utilise un type pointeur comme paramètre d'une fonction, ça veut dire que je peux modifier le contenu de l'adresse mémoire pointée.

Et c'est strictement identique.

Si on ne met pas de &, on peut modifier le contenu dans la fonction mais au retour de l'appelant, le contenu a gardé sa valeur initiale

Si tu mets pas de & (et pas de * non-plus), le paramètre est une variable créée par copie.
En fait le pointeur est aussi une copie, mais comme c'est l'emplacement pointé qui nous intéresse en général, on s'en moque.

[Papy214]

Code :

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

bool fileCanBeOpen(std::string  *filename)

Quelque chose dans le genre, c'est la bonne syntaxe pour avoir une chaîne de caractères modifiable ?

[bacelar]

Non

Code :

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

bool fileCanBeOpen(std::string& filename)

[Médinoc]

Code :

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

bool fileCanBeOpen(std::string  *filename)

Quelque chose dans le genre, c'est la bonne syntaxe pour avoir une chaîne de caractères modifiable ?

Disons que c'est quelque chose qui techniquement marcherait, mais ce n'est pas la façon recommandée.
Voir le message de bacelar.

PS: Je dois avouer que je suis assez hostile à la façon recommandée, parce que je n'aime pas les passages de paramètre modifiable sans une syntaxe qui le signale au moment de l'appel (comme c'est le cas en C#). Mais le gain en sécurité (plus de crainte de pointeur nul, etc.) compense la perte de lisibilité.

[Papy214]

Non

Code :

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

bool fileCanBeOpen(std::string& filename)

Là, le & est collé à string.

Dans la ligne copier-coller que j'avais au départ

Code :

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

bool fileCanBeOpen(std::string const & filename)

Est-ce à cause du const ajouté que le & est seul dans la déclaration ?

[Médinoc]

Collé ou pas, ça ne change rien, ce n'est qu'une question de style. Les gens vont avec ce qui leur parait le plus explicite.

[ternel]

en fait, comme string& n'est pas un identifieur valide, il est décomposé en deux: string, puis & (et de même pour const&).
Les espaces sont globalement superflux.

De même, tu aurais pu écrire bool fileCanBeOpen(std::string const &filename).

En C++, comme en C, le mot clé const porte sur le type situé à sa gauche, ou le mot à sa droite s'il n'y a rien à gauche. C'est pour cela que le fameux char const* est un pointeur modifiable de caractère constant. C'est aussi pour éviter la confusion avec un pointeur constant de caractère (un char * const) qu'on préfère placer le const à gauche dans le cas d'un pointeur (const char*).

Cela dit, les formes possibles pour une référence sur constante sont:

• std::string const & filename, qui regroupe la constance et la référence: le type "utile" est en premier, et le "bruit" technique placé après: l'utilisateur a surtout besoin de savoir que c'est une string, la référence sur constante est un détail qui pollue moins
• std::string const& filename, la forme compacte de la précédente.
• const std::string & filename, forme historique venue des vieilles habitudes du c (et des const char*)

Les arguments en faveur de l'une ou l'autre sont de grands sujets de troll, que l'on tranche normalement par "comme tu veux, tant que c'est cohérent et réfléchi"
Personnellement, je préfère la forme type const& nom parce que cela ressemble à un seul mot modificateur.
J'ai ainsi cinq modificateurs possibles: rien, const& et & et const* et * (qui aurai pu être des mots clés: copy, reference, mutable, potential et pointer)

[Papy214]

J'ai installé CodeBlocks et je ferai quelques essais de code dès que je pourrais.

Ce serait pas mal pour moi d'avoir quelques notions plus poussées sur ce langage et je reviendrai surement vous "casser les pieds" avec des questions de débutant.