當調用來自同一個非const版本重載成員函數時，可以刪除const限定符嗎？

Question

例如：

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); 
    } 
}; 

的事情是我想避免重複恆定FINDB和非恆定FINDB成員函數內的相同的邏輯。

Answer 1

是的，你可以投的對象const，調用const版本，然後把結果給非const：

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

虛擲const是安全的，只有當有問題的對象不是最初宣佈const。由於您在非const成員函數中，您可以知道這是情況，但它取決於實現。考慮：

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; 
}; 

一般來說，我的成員函數很短，所以重複是可以容忍的。您有時可以將實現歸入私有模板成員函數，並從兩個版本中調用該函數。

Answer 2

我認爲，在這裏使用投是好的，但如果你一定要避免它，你可以使用一些模板魔術：

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(); 
}