IP Girl
  1. IP Girl
  3. Utilisation de auto en C ++ 11
Intereting Posts
dplyr package peut-il être utilisé pour la mutation conditionnelle? Existe-t-il une option de ligne de commande maven pour le mode hors connexion? Pourquoi AddRange est-il plus rapide que d’utiliser une boucle foreach? INSERT avec SELECT Génère des couleurs entre le rouge et le vert pour un wattmètre? sqlite alter table ajoute MULTIPLE dans une seule déclaration Modifier la couleur de la ligne GridView en fonction de la condition Efficacité de Java “Initialisation à double attache”? Attention: en ignorant la valeur de retour de ‘scanf’, déclarée avec l’atsortingbut warn_unused_result remplacer Ssortingng par un autre en Java L’utilisation d’un mutex pour empêcher plusieurs instances du même programme de s’exécuter en toute sécurité Quelle est la qualité de l’UUID.randomUUID de java? Quelles ressources sont partagées entre les threads? Comment étirer la hauteur de div pour remplir le div parent – CSS Session TimeOut dans web.xml

Utilisation de auto en C ++ 11

Lorsque j’utilise auto pour déduire un type de pointeur, j’ai trouvé un phénomène étrange. Mon code est comme ceci: 

 #include  using namespace std; int main() { int i = 100; auto p1 = &i; auto *p2 = &i; cout << *p1 << " " << *p2 << endl; return 0; }

Après avoir compilé et exécuté, nous pouvons constater que le résultat de *p1 et *p2 est le même, tous les deux 100. Cela signifie que p1 et p2 sont tous deux un object pointeur qui pointe vers un object int . 

 [user@host ~]$ ./test 100 100

Y a-t-il une différence entre ces deux déclarations qui définissent p1 et p2 ?

La différence est que dans le premier cas, auto est déduit de int* alors que dans le second cas, auto est déduit de int , ce qui fait que p1 et p2 sont de type int* . Le mécanisme de déduction de type pour auto est équivalent à celui des arguments de modèle. La déduction de type dans votre exemple est donc similaire à 

 template void foo(T p1); template void bar(T* p2); int main() { int i; foo(&i); bar(&i); }

où les deux fonctions sont instanciées en tant que type void (int *) mais dans le premier cas T est déduit en int* tandis que dans le second cas T a le type int .

spécificateur auto utilisé dans les déclarations de variables, déduit son type avec les mêmes règles que celles utilisées dans la déduction des arguments de modèle .

Considérez votre premier exemple (c.-à-d., auto p1 = &i; ). Le type de spécificateur auto est déduit comme suit:

  1. auto est remplacé par un paramètre de type de type imaginaire (par exemple, U p1 = &i; ).
  2. &i type &i est int* , donc sans surprise et selon les règles de déduction du modèle, U est déduit de int* .

Considérons maintenant votre deuxième exemple (c.-à-d., auto *p2 = &i ).

  1. Encore une fois, auto est remplacé par un paramètre de modèle de type imaginaire (par exemple, U* p1 = &i; ).
  2. &i type est int* , donc selon les règles de déduction des modèles, U est déduit de int .

En tant que tel, dans auto *p2 = &i; Le type d’espace réservé auto sera correctement déduit en tant int et non en tant int* , ce qui aurait pour résultat que p2 serait de type int** , comme vous vous en doutiez.