Je connais le sujet de passe par référence par rapport au pointeur est fortement couvert ... à peu près sûr que j'ai compris toutes les nuances jusqu'à ce que je lisais ceci:
HTPTP://carlo17.home.xs4all.nl/cpp/const.qualifier.html
Qui est lié (au cas où le lien va mort) Qu'est-ce que l'auteur signifie par "note que je mets le const au droit de type parce que nous ne savons pas si le type ... est un pointeur ou pas! " Tout ce que j'ai lu sur ce sujet a été cohérent de dire que: VOID Foodbar (type const &) est également équivalente void foobar (Const type &) Si je comprends l'auteur correctement, il dit que: const int * x vs int * const X où le pointeur, x lui-même est constitué contre ce que X pointe à Const? Si oui, est-ce vrai?
3 Réponses :
En regardant Le C ++ FAQ Lite (Au fur et à mesure que l'article suggère), vous lisez des déclarations de pointeur de droite à gauche. Donc, si le type est un pointeur, le placement du * fait une différence. Suivez le lien pour l'histoire complète.
Seulement si le type est un macro qui se développe à un type de pointeur. Si c'est un paramètre TypeDEF ou un modèle, alors Const Type & signifie la même chose que Tapez Const & , même si le type réel est un type de pointeur. Cela fait partie de la raison de l'utilisation de Typefs :)
La référence dans la question initiale dit: "Considérons un type de type arbitraire". L'auteur ne faisait clairement pas référence à une macro.
Donc, étant donné que la réponse est simplement fausse: un type Typef'd est traité comme une unité et vous ne pouvez pas finir par insertion const s au milieu de cette déclaration de type. Const Type & signifie la même chose que le type Const & , même si le type pourrait être "brisé" pour offrir une autre position pour le mot clé const .
Au lieu de taper, utilisons Fred (pour éviter les connotations d'un type tout-caps - qui crie la macro! Pour moi). Donc, pour résumer de la FAQ: Fred Const * P signifie "P pointe sur une constante Fred": l'objet Fred ne peut pas être changé via p. Fred * const p signifie "p est un pointeur constant à une Fred": vous ne pouvez pas changer le pointeur P, mais vous pouvez changer l'objet Fred via p. Fred Const * Const P signifie "P est un pointeur constant à une constante Fred": Vous ne pouvez pas modifier le pointeur P lui-même, vous ne pouvez pas modifier l'objet Fred via p. Donc, pour un type de pointeur, le placement du const par rapport au type compte.
Dans la mesure où "le placement de const par rapport à un type de pointeur est important", il n'est pas valide d'utiliser Fred pour décrire un type de pointeur. Si Fred est un typef pour INT *, puis const fred & signifie identique que Fred const & , ce qui signifie la même chose que int * Const & . Il ne signifie pas signifie const int * & , qui est identique à celui de int const * & .
Une illustration: Typef int * Fred; int x; const Fred référé_to = & x; <- int * const = const (int *), non (const int) * const int * & f = référence_to; <- Erreur: invalide: non valide: Initialisation de la référence de type 'const int * &' de l'expression de type 'int * const' int * const & g = référé_to; / * ok * / const fred & h = référencé_to; / * OK * / Fred Const & I = référencé_to; /* aussi OK! * / Comme vous pouvez le constater, l'emplacement du "const" par rapport au type def fait pas matière.
Comme je l'ai dit, si type (ou Fred ou Fred , écrit par une personne qui ne respecte pas les conventions) est une macro, Ensuite, La position est compatible, car la macro sera substituée par le Textuel avant que le type global ne soit analysé.
Si le type est un Si le type est un paramètre TypeDEF ou un paramètre de modèle, le Pour moi, cela ressemble plus à un autre argument contre les macros, plutôt qu'un besoin de style spécifique dans les déclarations. #define pour quelque chose comme int * , le placement de const est important. Dans ce cas, vous obtiendrez const int * ou int * const en fonction de l'emplacement de const .
const affectera le type entier de chaque sens.
+1, et pourtant je préfère utiliser le const sur le côté droit ... pour la cohérence. (Mais j'ai une sensation plus forte pour les macros que pour la position du const !)
@David: Des sentiments forts pour les macros sont courants. Je soupçonne que je partage le vôtre.
typedef SomeStruct* pSomeStruct;
void foobar(pSomeStruct* const &); // const reference to a pointer
// to a pointer to SomeStruct
void foobar(const pSomeStruct* &); // reference to a pointer
// to a const pointer to const SomeStruct
Pour ce faire, vous devez être beaucoup plus précis sur ce que vous entendez par "Type est Un pointeur ...". Voir mon commentaire sur l'autre réponse.
@Karl: Je fais que votre argument sur Typefs est une unité. Cependant, ce que j'ai dit a du sens même s'il y a un pointeur à un type de typeEFD.
Voir Stackoverflow.com/questions/2640446/...
L'auteur mal incompte la langue (les deux sont identiques ), et honnêtement, je n'ai aucune idée de ce qu'il essaie de dire. Encore une autre raison d'obtenir un livre et de ne pas essayer d'apprendre de certains articles en ligne.
L'achat d'un livre ne garantit pas que vous avez une ressource de qualité, même des livres populaires: SeeBS.net/ C / C_TCN4E.HTML
Si vous avez manqué ce que j'ai écrit, voici à nouveau: «Tout ce que j'ai lu sur ce sujet a été cohérent." Cela inclut plusieurs livres. En particulier "Professional C ++" de Nicholas A. Solter, Scott J. Kleper à la page 332 se lit comme suit: "N'oubliez pas que Const Int & Zref est équivalente à Int Cons & Zref." Amazon.com/professionnel-c-programmer-nicholas-solter/nicholas-solter/ DP / ...