Ist es in Ordnung, const-Qualifikationsmerkmal zu entfernen, wenn der Aufruf von derselben nicht-const-Version überladenen Mitgliedsfunktion stammt?

Question

Zum Beispiel:

struct B{}; 

struct A { 

const B& findB() const { /* some non trivial code */ } 

// B& findB() { /* the same non trivial code */ } 

B& findB() { 
     const A& a = *this; 
     const B& b = a.findB(); 
     return const_cast<B&>(b); 
    } 
}; 

Die Sache ist, ich die gleiche Logik Wiederholung innerhalb des konstanten FINDENB und nicht konstanter FINDENB Memberfunktion zu vermeiden.

Answer 1

Ja, Sie das Objekt const werfen können, rufen Sie die const Version, warf dann das Ergebnis const auf nicht:

return const_cast<B&>(static_cast<const A*>(this)->findB()); 

Casting weg const sicher ist nur, wenn das betreffende Objekt war ursprünglich nicht erklärt const. Da Sie sich in einer Member-Funktion befinden, die nicht in der const ist, können Sie wissen, dass dies der Fall ist, aber es hängt von der Implementierung ab. Überlegen Sie:

class A { 
public: 

    A(int value) : value(value) {} 

    // Safe: const int -> const int& 
    const int& get() const { 
     return value; 
    } 

    // Clearly unsafe: const int -> int& 
    int& get() { 
     return const_cast<int&>(static_cast<const A*>(this)->get()); 
    } 

private: 
    const int value; 
}; 

Im Allgemeinen sind meine Mitgliedsfunktionen kurz, so dass die Wiederholung tolerierbar ist. Sie können die Implementierung manchmal in eine private Template-Member-Funktion einbeziehen und diese aus beiden Versionen aufrufen.

Answer 2

Ich denke, dass hier werfen Verwendung ist in Ordnung, aber wenn man es auf jeden Fall vermeiden wollen, können Sie einige Vorlage Magie:

struct B 
{ 
    B(const B&) 
    { 
     std::cout << "oops I copied"; 
    } 
    B(){} 
}; 

struct A { 
public: 
    A(){} 
    A(const A&){ std::cout << "a is copied:(\n";} 
    const B& findB() const { return getter(*this); }  
    B& findB() { return getter(*this); } 

private: 
    template <typename T, typename V> 
    struct same_const 
    { 
     typedef V& type; 
    }; 

    template <typename T, typename V> 
    struct same_const<const T, V> 
    { 
     typedef const V& type; 
    }; 

    template <typename T> 
    static typename same_const<T,B>::type getter(T& t) { return t.b;} 

    B b; 

}; 

int main() 
{ 
    A a; 
    const A a_const; 
    const B& b1 = a.findB(); 
    B& b2 = a.findB(); 

    const B& b3 = a_const.findB(); 
    //B& b4 = a_const.findB(); 
}