Passer la référence const mène au paradoxe dans le code ..?

Question

Ok j'ai donc une fonction au sein d'une classe nommée vector_ref

class vector_ref { 
    public: 
     int* data() const { return m_data } 
     void retarget(std::vector<int> const& _t) 
     { m_data = _t.data(); 
     m_count = _t.size() } 
    private: 
     int* m_data; 
     size_t m_count; 
} 

Je suis en train de recibler un objet vector_ref à un objet vectoriel existant nommé v qui est peuplée par ints et les données appelez().

vector_ref<int> tmp; 
tmp.retarget(const_cast<std::vector<int> const&>(v)); 
tmp.data(); // error here 

Le passage à recibler compiles, mais appelant des données() donne l'erreur:

invalid conversion from const int* to int* { m_data = v.data() ... } 

Cela me semble logique, comme la variable membre m_data n'est pas const, mais étant donné cette définition de classe comment puis-je jamais retarget à un existant vector. Si je dois passer par const référence à retarget(), qui définit la variable membre constm_data, comment puis-je jamais espérer compiler avec succès le code retargets avec succès l'instance vector_ref?

Answer 1

Tout comme m_data déclare

const int* m_data; 

Cela ne signifie pas que m_data est const. Cela signifie que vous ne pouvez pas modifier le int points m_data. Alors, vous pouvez encore ceci:

m_data = _t.data(); 

Mais vous ne pouvez pas faire ceci:

*m_data = x; 
m_data[5] = y; // or this 

Par ailleurs, il n'y a pas besoin de votre const_cast. Vous auriez besoin de const_cast si vous supprimiez le qualificateur const (c'est-à-dire en passant un objet const à une fonction qui attend une référence non-const). Vous n'en avez pas besoin pour passer un objet non-const à une fonction qui accepte une référence const.