auto keyword und oberste Ebene, niedrige Pegelkonstanten

Question

In C++ - Primer wird erwähnt, dass - auto automatisch Oberste Ebene Konstanten ignoriert. Wie üblich werden bei Initialisierungen Low-Level-Konstanten, beispielsweise wenn ein Initialisierer ein Zeiger auf eine Konstante ist, beibehalten.

const int ci = i,&cr=ci; 

auto b=ci; //ok:b is an int (top level constants in ci is ignored) 

auto d=&i; //d is an int* (& of a int object is int *) 

auto e=&ci; // e is a const int *(& of a constant object is a low level constant) 

Jetzt ist meine Frage: In der 2. Anweisung wird const ignoriert und Typ von B ist Int. Aber in der letzten Anweisung wird die Konstante von ci nicht ignoriert und der Typ ist const int *, anstatt int *. Warum ??

Answer 1

Wenn Sie auto b=ci; verwenden, erstellen Sie eine Kopie von ci. So hat C++ keinen Grund, Sie daran zu hindern, den Wert b zu ändern. Aber wenn Sie auto e=&ci; verwenden, erstellen Sie einen Zeiger der Const-Int-Variable ci. e sollte ein Zeiger auf einen konstanten Wert sein, um zu verhindern, dass Sie den Wert ci ändern.

Answer 2

Es ist eine niedrige Konstante, weil es direkt darauf verweist. auto b = ci kopiert den Wert von ci zu b, aber auto e = &ci muss einige const -ness haben, da es ci NICHT kopiert, sondern stattdessen zeigt, wo ci existiert. Der Begriff niedriges Niveau bedeutet in diesem Fall, dass es wenig Umleitung gibt.

Answer 3

Die Verwendung von

const int i = ...; 

ein const Objekt definieren ist für eine lange Zeit eine Quelle der Verwirrung. Es lässt die Leute das denken;

const int* ptr = ...; 

definiert auch einen const Zeiger. Das wäre eine falsche Schlussfolgerung. Wenn Sie die const ein bisschen bewegen, ist es weniger verwirrend.

int i = ...;     // Defines i to be a non-const object 
int const i = ...;   // Defines i to be a const object 

int* ptr = ...;    // Defines ptr to be a non-const pointer to a non-const object 
int const* ptr = ...;  // Defines ptr to be a non-const pointer to a const object 
int* const ptr = ...;  // Defines ptr to be a const pointer to a non-const object 
int const* const ptr = ...; // Defines ptr to be a const pointer to a const object 

kommend auf die Frage der Top-Level-cv-Qualifizierer,

int const i = ...; 

definiert ein Objekt, dessen Typ int und es hat const Qualifier.

int volatile i = ...; 

definiert ein Objekt, dessen Typ int und es hat volatile Qualifier.

int const* ptr = ...; 

definiert ein Objekt, dessen Typ int const* aber es hat keine const oder volatile Qualifier. Der Typ der zweiten Ebene, int, hat const Qualifier, jedoch nicht den Typ der obersten Ebene.

int const* const ptr = ...; 

definiert ein Objekt, dessen Typ int const* und es hat const Qualifier. Der Typ der zweiten Ebene, int, hat auch const Qualifier.

int * const ptr = ...; 

definiert ein Objekt, dessen Typ int* und es hat const Qualifier.Der Typ der zweiten Ebene, int, hat keinen Qualifizierer const.

Weitere Informationen:

Where is the definition of `top-level cv-qualifiers` in the C++11 Standard?
What are top-level const qualifiers?

Answer 4

Sie haben vergessen int i=0; Hier i können im Rahmen des Programms zu erwähnen ändern, die es nicht konstant macht.

In der zweiten Anweisung wird const

es also ignoriert kein Top-Level-const ignoriert werden

Actual Code in C++ Primer,

int i = 0;//Value of i is 0 but it might change 
const int ci = i;//Value of ci will not change once initialized 
auto d = &i;//Hence d is an int*(No top-level const) 

In der letzten Anweisung wird die Konstante von ci nicht ignoriert

& eines konstantes Objekt ist ein Low-Level-const, die auto nicht

auto e = &ci;// e is const int*(low-level const)