c++ - datos - ¿Por qué no se impone constness para los punteros?

conversion de tipos de datos en c++

Question

Considere el siguiente fragmento de código:

class A
{
public:

    void nonConstFun()
    {

    }
};

class B
{
private:

    A a_;
    A * pA_;

public:

    void fun() const
    {
        pA_->nonConstFun();
        //a_.nonConstFun(); // Gives const related error
    }
};

int main()
{
    B b;
    b.fun();
}

Aquí estoy esperando que el compilador falle en la compilación por falta de constancia para llamar a A::nonConstFun() dentro de B::fun() independientemente del tipo de objeto A.

Sin embargo, el compilador se queja por el objeto, pero no por el puntero. ¿Por qué? Estoy utilizando VS2017 en Windows 10.

Answer 1

Las otras respuestas explican la T* const vs T const * que es lo que está sucediendo. Pero es importante entender la implicación de esto más allá de la mera sintaxis.

Cuando tienes una T* dentro de una estructura, el puntero está dentro del objeto, pero el objeto puntiagudo está físicamente fuera de la estructura. Es por eso que para un objeto const con un miembro T* no se permite modificar el puntero, pero sí se puede modificar el objeto puntiagudo, ya que físicamente el objeto puntiagudo está fuera del objeto que lo contiene.

Y le corresponde al programador decidir si el objeto puntiagudo es lógicamente parte del objeto envolvente (y como tal debería compartir la constancia con el envolvente) o si es lógicamente una entidad externa.

El inconveniente de C ++ es que no ofrece una manera fácil de expresar una constancia lógica como se indicó anteriormente (lo que realmente esperaba de su código).

Esto se conoce y para este propósito exacto hay una clase experimental que aún no es estándar propagate_const

std :: experimental :: propagate_const es un contenedor de propagación constante para punteros y objetos tipo puntero. Trata el puntero envuelto como un puntero a const cuando se accede a través de una ruta de acceso constante, de ahí el nombre.

struct B
{
    A a_;
    std::experimental::propagate_const<A *> pA_;

   void fun()
    {
        pA_->nonConstFun(); // OK
    }
    void fun() const
    {
        // pA_->nonConstFun(); // compilation error
    }
};

Answer 2

Se hace cumplir.

Si intentas cambiar el puntero, el compilador no te dejará.

Lo que apunta el puntero, sin embargo, es una conversación diferente.

Recuerda, T* const y T const* no son lo mismo!

Puede proteger eso haciendo que sea realmente A const* , o simplemente escribiendo su función de la manera apropiada.