class Coo2
{
public:
Coo2() : p(new int(0)) {}
~Coo2() {delete p;}
int const * getP() const
{
*p = 1;
return this->p;
}
private:
int* p;
};
9 Réponses :
Non, le mot clé Il est parfaitement bien d'avoir un pointeur de const avant le * signifie que la variable que vous indiquez est une variable "const" et que seule elle ne peut pas être modifiée.
foo * const p = & bar;
const foo * const p = & bar
const int * foo être attribué à un pointeur de const int * consons bar Tout comme ça va bien avoir un < Code> int S attribué à un const int . Pensez-y de la même manière.
int const * est la même chose que const int *
Je sais, c'est fou. int const * p; et const int * p sont les mêmes. C'est lorsque le const vient après le * que
la sémantique de l'expression change.
int Const * getp () const , est-ce que le dernier const signifie que je ne peux pas changer * p (ce que le p pointe)?
Ok, votre attention portée aux détails consiste à apprendre la langue (ce n'est pas une mauvaise chose). Lorsque le const va après une signature de fonctions, cela signifie que la fonction de membre (coloquily, une définie pour appartenir à un objet) a l'intention de ne pas modifier à un objet. Le compilateur applique cette intention dans une certaine mesure. Donc, si ladite fonction écrit ou appelle une fonction qui peut écrire sur l'objet, en question ou dans tout autre moyen indirect (mais détectable par le compilateur), le compilateur lancera une erreur.
@Bug: Non, cela signifie que la fonction membre est const . Avez-vous un Bon livre d'introduction ?
@gman WOW Belle ressource, j'étais sur le point de lui laisser un commentaire pour donner une référence au livre de Bjarne depuis qu'il est tellement intéressé par la mécanique de la langue: D
@Hassan SYED Cela signifie que la fonction membre a l'intention de ne pas modifier à un objet. mais j'ai changé la valeur de * p dans la deuxième section de code. Ou le const signifie que je ne peux pas changer p ?
MSDN.MicRosoft.com/en-us/Library /6ke686zh(v=vs.80).aspx Selon MSDN, rien dans la modification ne peut être modifié par une fonction de membre Const, il s'agit simplement d'un "observateur" (ce terme est également utilisé).
const int * const p = &i1;
Les deux sont exactement les mêmes. Ce qui compte, c'est la position du qualificatif relatif à l'astérisque ( * ):
La deuxième section de code: int Const * getp () const, le dernier Constossans je ne peux pas changer * p (ce que le P est pointé)?
@BugCripeater: Non - C'est un qualificatif sur une fonction membre, affirmant que la fonction ne modifie pas l'état de son objet. Il peut donc être appelé sur un objet Const.
Avec l'aide du pointeur, vous pouvez réellement faire deux choses.
Maintenant, quand vous dites, int Const * PTR ou int Const * PTR, il tombe sous la première catégorie. C'est la même chose que - à, réellement impossible de passer à un emplacement différent, c'est-à-dire le pointeur à un emplacement constant, mais être en mesure de modifier les données, la sémantique devrait être Cependant, il y a un troisième type. Pointeur constant à un emplacement constant, qui ne peut ni signaler à un emplacement de mémoire différent ni modifier les données qu'il pointe. (C'est-à-dire, const int * const) et maintenant dans l'extrait ci-dessus, espoir, vous comprenez maintenant pourquoi le programme compile :) int * const . Étant donné que le contenu du pointeur est une constante, il devrait être initialisé pendant la déclaration. p3 est un pointeur constant à un emplacement constant. Donc, il ne peut pas être modifié. const à la fin d'une fonction membre dit qu'il ne changera pas l'état de l'objet. Lorsque vous dites * p = 1; , vous ne modifiez pas l'état de l'objet. P Pointe toujours sur la même mémoire. Ceci n'est pas autorisé à faire -
Ici, nous considérons ici 4 types de déclarations de pointeurs:
int * w;
Cela signifie que w est un pointeur sur une valeur de type entière. Nous pouvons modifier à la fois le pointeur et son contenu. Si nous initialisons W alors que la déclaration ci-dessous:
int * w = & a;
Ensuite, les deux opérations ci-dessous sont viables:
w = & b; (vrai)
* w = 1; (vrai)
int * const x;
Cela signifie que X est un pointeur constant qui pointe vers une valeur de type entière. Si nous initialisons x tandis que la déclaration ci-dessous:
int * const x = & a;
Ensuite, nous ne pouvons pas faire: x = & b; (incorrect) car x est un pointeur constant et ne peut pas être modifié.
Cependant, il est possible de faire: * x = 1; (vrai) , car le contenu de x n'est pas constant.
int const * y; // les deux signifient le même
const int * y;
Cela signifie que y est un pointeur qui pointe une valeur inteer constante. Si nous initialisons y tandis que la déclaration ci-dessous:
int const * y = & a;
Ensuite, il est possible de faire: y = & b; (true) car y est un pointeur non constant qui peut pointer vers n'importe où.
Cependant, nous ne pouvons pas faire: * y = 1; (faux) parce que la variable que les points y est une variable constante et ne peut pas être modifiée.
int Const * const z; // les deux signifient le même
const int * const z;
Cela signifie que z est un pointeur constant qui pointe vers une valeur entière constante. Si nous initialisons z pendant que la déclaration ci-dessous:
int Const * const z = & A;
Par conséquent, non des opérations ci-dessous sont viables:
z = & b; (faux)
* z = 1; (incorrect)
succinctement; chaque combinaison de lecture / écriture int / pointeur;
Voici un pointeur à une constante:
p = &x;
Const s'applique à la chose à gauche, sauf s'il n'y ait rien à gauche auquel cas il s'applique à la chose à droite. (Oui, ceci est inutilement déroutant et stupide.)Const au bout de la fin signifie qu'aucun changement ne sera apporté à l'objet / classe.