int foo = 11;
int *p = &foo;
auto pp = p;
auto *ppp = p;
cout << pp << endl;
cout << ppp << endl;
Ce programme produira la même sortie pour pp
et ppp
, mais pourquoi? auto
déduit que la variable doit être int
, donc je pense que la déclaration de ppp
est juste. Mais pp
et ppp
ont la même valeur ...
Production:
0x61fefc
0x61fefc
Dans l'exemple particulier que vous montrez, il n'y a pas de différence. Mais imaginez que vous ajouteriez plus tard deux qualificatifs const
comme suit:
const auto pp = p;
const auto *ppp = p;
Est-ce toujours la même chose? Il s'avère que c'est identique à
int * const pp = p; // pointer is readonly
const int *ppp = p; // pointer is readonly
parce que dans auto pp = p
, auto
correspond à int*
dans son ensemble, et const
modifie ce qui est à sa gauche (ou ce qui est à sa droite, s'il n'y a rien à sa gauche). Au contraire, dans auto *ppp = p
, auto
correspond à int
, et c'est à cela que const
s'applique.
En raison de cette différence notable et parce que nous devrions utiliser les variables const
dans la mesure du possible, je vous conseille de toujours utiliser auto*
lors de l'utilisation de la déduction de type pour les variables de pointeur. Il n'y a aucun moyen de const
- qualifier le pointeur lui-même au lieu de la pointe, et si vous voulez const
- qualifier les deux, cela est possible en
const auto * const pppp = p;
qui ne fonctionne pas sans le *
.
Il n'y a pas de différence entre auto
et auto *
dans ce cas particulier. En cas de auto pp = p;
le type sera déduit de int *
en cas de auto *ppp = p;
le type sera déduit de int
.
Pour les variables, spécifie que le type de la variable déclarée sera automatiquement déduit de son initialiseur. [...]
Notez que contrairement à auto
le auto *
ne déduira que les types de pointeurs.