Eredita dalla classe const

Question

vorrei ereditare da una classe con il const identificatore in questo modo:

class Property 
{ 
    int get() const; 
    void set(int a); 
}; 

class ConstChild : public const Property 
{ 
    // Can never call A::set() with this class, even if 
    // the instantiation of this class is not const 
}; 

class NonConstChild : public Property 
{ 
    // Can call both A::set() and A::get() depending on 
    // the constness of instantiation of this class 
}; 

mio compilatore mi dà evidentemente un errore per la parola chiave const nella seconda dichiarazione di classi. Idealmente, vorrei evitare di dover creare una nuova classe ReadOnlyProperty da cui ereditare ConstChild.

Posso in qualche modo utilizzare la parola chiave const per l'ereditarietà?

• In caso contrario, avete altre idee su come risolvere questo problema?

Answer 1

vorrei ereditare da una classe con l'identificatore const"

Per quanto si desidera è irrilevante. Non è possibile. Questo non è valida C++.

Posso in qualche modo usare la parola chiave const per l'ereditarietà? "

No.

Answer 2

Se si crea una funzione const membro set, otterrete quello che vi serve.

class Property 
{ 
    int get() const; 
    void set(int a); 
}; 

class ConstChild : public Property 
{ 
    void set(int a) const {} 
}; 

L'unica avvertenza è che un utente malizioso può aggirare la vostra intenzione utilizzando:

ConstChild child; 
child.set(10); // Not OK by the compiler 

Property& base = child; 
base.set(10); // OK by the compiler 

Answer 3

Introdurre mutevolezza più avanti nel vostro albero di eredità e ricavare in modo appropriato:

class Property 
{ 
    int get() const; 
}; 
class MutableProperty : public Property { 
{ 
    void set(int a); 
}; 

E poi:

class ConstChild : public Property { ... }; 
class MutableChild : public MutableProperty { ... }; 

Answer 4

Utilizzare un membro dati o una classe base privata invece della classe base pubblica.

Quindi si controlla l'accesso a quel membro.

È possibile impostare la proprietà come un'interfaccia astratta se si desidera un comportamento polimorfico.

Answer 5

Ho un trucco, non una soluzione pulita.

class ConstChild : private Property 
{ 
    operator const Property() { return *this; } 
}; 

poi

ConstChild cc; 
cc.set(10); // ERROR 
cc().get(); 

Answer 6

È possibile utilizzare una classe template e una specializzazione per un tipo di costante:

template<typename T> class base_property { 
    protected: 
     T value; 
    }; 
    template<typename T> class property : public base_property<T> { 
    public: 
     const T& get()const { return value; } 
     void set(const T& v){ value = v; } 
    }; 

    template<typename T> class property<const T> : public base_property<T> { 
    public: 
     const T& get()const { return value; } 
    }; 

    class ConstChild : public property<const int>{ };