Un oggetto con allocazione heap può essere const in C++?

Question

In C++ un oggetto stack allocato può essere dichiarato const:

const Class object; 

dopo che il tentativo di chiamare un metodo non const su tale oggetto è un comportamento indefinito:

const_cast<Class*>(&object)->NonConstMethod(); //UB 

Può un mucchio allocate oggetto essere const con le stesse conseguenze? Voglio dire è possibile che il seguente:

const Class* object = new Class(); 
const_cast<Class*>(object)->NonConstMethod(); // can this be UB? 

è anche un comportamento non definito?

Answer 1

Sì. È legale costruire e distruggere un oggetto heap const. Come con altri oggetti const, i risultati della manipolazione come oggetto non-const (ad esempio attraverso un const_cast di un puntatore o riferimento) causano un comportamento non definito.

struct C 
{ 
     C(); 
     ~C(); 
}; 

int main() 
{ 
     const C* const p = new const C; 

     C* const q = const_cast<C*>(p); // OK, but writes through q cause UB 

     // ... 

     delete p; // valid, it doesn't matter that p and *p are const 

     return 0; 
} 

Answer 2

Nell'esempio di heap, new restituisce un puntatore a non-const. Il fatto di averlo memorizzato in un puntatore su const (e quindi su const_cast ed è tornato a un puntatore a non-const) non cambia il fatto che l'oggetto stesso non è const nello stesso modo dello stack allocato uno è.

Tuttavia, è possibile crea un oggetto const sul mucchio:

const Class* object = new const Class(); 

In tal caso, la fusione a un puntatore a non-const e chiamando un metodo non-const sarebbe la stessa situazione come oggetto const-allocato allo stack.

_{(L'idea di creare un oggetto const sul mucchio era nuovo per me, non avevo mai visto prima. Grazie a Charles Bailey.)}

Answer 3

Ovviamente:

struct Foo { 
    const int Bar; 
    Foo() : Bar(42) { } 
}; 

Foo* foo = new Foo; 
const_cast<int&>(foo->Bar); // don't do this. 

Answer 4

Sì, un oggetto mucchio allocato può essere const. Considerate questo estratto dall'esempio in 7.1.5.1/5:

const int* ciq = new const int (3); // initialized as required 
int* iq = const_cast<int*>(ciq);  // cast required 
*iq = 4;        // undefined: modifies a const object 

L'esempio che ha dato per la questione va bene perché non stai chiedendo new per rendere un oggetto const; stai semplicemente memorizzando il risultato in un puntatore-a-const.

Answer 5

const_cast può causare UB quando l'oggetto è in realtà di sola lettura (ad esempio, il compilatore può creare tali oggetti quando si utilizzano stringhe codificate nel codice, posizionandoli in determinate aree di memoria che sono di sola lettura) per alcuni ragionare. Questo non succederà con gli oggetti allocati nell'heap, indipendentemente da come si mantiene il loro riferimento (puntatore const, riferimento const, qualunque).

Answer 6

Non dimenticare mutevoli membri

Non sarà comportamento undefinied se il NonConstMethod modifica solo mutable membri qualificati (vedi 7.1.5.1 (4)) di una classe qualificato const. Sì, altrimenti è un comportamento indefinito.

const A* p = new(const A); 
A *q = const_cast<A*>(p); 
q->NonConstMethodThatModifiesMembers();    // undefined behaviour! 
q->NonConstMethodThatOnlyModifiesMutableMembers(); // defined behaviour!