C++: ungültige Initialisierung von Referenz des Typs 'const int * &' aus dem Ausdruck des Typs 'int *'

Question

int *b = new int(); 
const int *&a = b; 

Die IDE "invalid Initialisierung von Referenz des Typs const int*& aus der Expression int* Typ" zeigten

I verstehe nicht.

Answer 1

Sie können keine Referenzen mit verschiedenen Typen binden; für diesen Fall sind sie int * und const int*.

Für const int *&a = b; ist b ein int* und muss dann zunächst const int* umgewandelt werden. Die implizite Konvertierung ist hier erlaubt, aber die konvertierte const int* ist eine temporäre und kann nicht an a gebunden werden; weil es eine lvalue-Referenz zu nicht-const ist.

Auf der anderen Seite, werden temporary object könnte Lvalue Verweis gebunden a als L-Wert-Verweis auf const Zeiger auf const oder R-Wert-Referenz, dh

const int * const &a = b; // fine, and the lifetime of the temporary is extended to match the lifetime of the reference a 

Beachten Sie die Position der const, jetzt erklärt zu const int.

Answer 2

• b ist ein Zeiger auf Int.
• a ist eine Referenz auf einen Zeiger auf const int.

So b ist nicht zu a zuweisbar.

Sie wollen wahrscheinlich einen Verweis auf einen const Zeiger anstatt auf int:

int *b = new int(); 
int *const &a = b; 

Answer 3

Das Problem ist, dass diese beiden Typen

int * 

und

const int * 

sind zwei verschiedene Typen. Somit wird der Ausdruck auf der rechten Seite, der die Variable b ist, in rvalue vom Typ const int * umgewandelt.

Sie können eine nicht konstante Referenz nicht an eine rvalue binden. So haben Sie

const int * const &a = b; 

Answer 4

Der formale Grund zu schreiben ist, dass int* und const int* unterschiedliche Typen sind, und die Umwandlung erzeugt eine temporäre, und man kann nicht eine nicht konstante Referenz auf ein temporäres binden.

So dass es ein Verweis auf const Zeiger funktionieren würde:

const int * const &a = b; 

für ein motivierendes Beispiel, nehmen wir an, dass dies erlaubt wurden:

int* p = nullptr; 
const int*& rp = p; 

rp und p jetzt auf das gleiche Objekt beziehen.

Lassen Sie uns eine const int machen.

const int y = 1; 

zuordnen const int*-const int* sollte sicher sein, nicht wahr ?.

rp = &y;   

Jetzt, da *p nicht const ist, dass wir einen neuen Wert zuweisen können:

*p = 0xbaad1dea; 

Aber p ist das gleiche Objekt wie rp und *rp ist y so *p ist auch y und y ist const

und jetzt sind wir im Land des undefinierten Verhaltens.