cómo preservar const corrección a través de punteros?

Question

Estoy tratando de tener una constante de la operación en una clase que es verdaderamente const - no cambiar los datos que la clase de puntos.

Por ejemplo:

class Node{
public:
    int val;
};
class V{
public:
    Node * node; //what is the change that is needed here?
    void const_action()const{
        node->val=5; //error wanted here
    }
    void action(){
        node->val=5; //error is not wanted here
    }
};

Answer 1

Puede usar una plantilla para hacer cumplir la corrección del Const en un puntero sin cambiar el significado o la implementación de su clase:

    template <typename T>
class PreseveConstPointer
{
    T *t_;
public:
    PreseveConstPointer(T *t = nullptr)
        : t_(t)
    {
    }
    PreseveConstPointer<T> * operator=(T *t)
    {
        t_ = t;
        return this;
    }
    T* operator->()
    {
        return t_;
    }
    T const * operator->() const
    {
        return t_;
    }
    T * data()
    {
        return t_;
    }
};
class Node{
public:
    int val;
};
class V{
public:
    PreseveConstPointer<Node> node;
    V()
    {
        node = new Node;
    }
    ~V()
    {
        if(node.data())
            delete node.data();
    }
    void const_action()const{
        node->val=5; // You will get an error here
    }
    void action(){
        node->val=5; // No error here
    }
};

Answer 2

const después de una declaración de función, dice que la función no está permitido cambiar los miembros de la clase (excepto los que están marcados mutable).

Dado que el código no cambia cualquier miembro de la clase, y sólo cambia el objeto node los puntos a, tanto en función de compilar.

AFAIK no hay forma de evitar esto.Si usted marca la node const, ni va a compilar.

Answer 3

Estás confuso Node* const para Node const*.

Un [lamentable?] efectos secundarios del uso de indirección aquí es que constness del puntero miembro no tiene nada que ver con la real Node en el que estamos operando.

Si usted no necesita a ese miembro a ser un puntero, entonces este es agradablemente fácil:

class V
{
public:
    Node node;

    void const_action() const
    {
        node.val = 5; // error here
    }

    void action()
    {
        node.val = 5; // no error here
    }
};

Sin embargo, dado su nombre, sospecho que la vida no es así de simple y básicamente están de suerte.