¿Puede un objeto asignado en el montón const en C++?

Question

en C++ un objeto pila-asignado puede ser declarado const:

const Class object; 

después de que tratando de llamar a un método no const en tal objeto es un comportamiento indefinido:

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

Puede un heap-asignados objeto sea const con las mismas consecuencias? Quiero decir, ¿es posible que lo siguiente:

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

también es comportamiento indefinido?

Answer 1

Sí. Es legal construir y destruir un objeto de montón const. Al igual que con otros objetos const, los resultados de manipularlo como un objeto no const (por ejemplo, a través de const_cast de un puntero o referencia) producen un comportamiento indefinido.

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

En su ejemplo de pila, new devuelve un puntero a no const. El hecho de que lo hayas almacenado en un puntero para const (y luego const_cast lo devolvió a un puntero para no const) no cambia el hecho de que el objeto en sí no es const del mismo modo que el stack asignado uno es.

Sin embargo, puede crear un objeto constante en el montón:

const Class* object = new const Class(); 

En tal caso, echando a un puntero a no constante y llamar a un método no constante sería la misma situación como el objeto const stack-assigned.

_{(La idea de crear un objeto constante en el montón era nuevo para mí, que nunca había visto antes. Gracias a Charles Bailey.)}

Answer 3

Obviamente:

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 montón de objetos asignados puede ser const. Consideremos este extracto del ejemplo en 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 

El ejemplo que diste en la pregunta está bien porque usted no está pidiendo new para hacer un objeto constante; solo estás almacenando el resultado en un puntero-a-const.

Answer 5

const_cast puede causar UB cuando el objeto es realmente de solo lectura (por ejemplo, el compilador puede crear tales objetos cuando usa cadenas codificadas en su código, colocándolos en ciertas áreas de memoria que son de solo lectura) para algunos razón. Esto no sucederá con los objetos asignados en el montón, sin importar cómo conserve su referencia (indicador de const, referencia de referencia, lo que sea).

Answer 6

No se olvide mutables miembros

No va a ser el comportamiento undefinied si el NonConstMethod sólo modifica mutable miembros calificados (ver 7.1.5.1 (4)) de una clase calificada const. Sí, de lo contrario es un comportamiento indefinido.

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