如何根据模板参数创建一个const方法？

Question

我有一个带有模板参数的类，我想调用它的一个方法。它看起来是这样的：

template <typename T> 
class Foo { 
public: 
    void doSomething() { 
     for (auto& t: ts) { 
      t.doSomething(); 
     } 
    } 
private: 
    std::vector<T> ts; 
}; 

这工作，但我想使doSomething()常量如果T本身是常量（假设T::doSomething()将是const太）。我找到了一个可能的解决方案（基于this question），但我不喜欢它。

template <bool enabled = std::is_const<T>::value> 
typename std::enable_if<enabled, void>::type 
doSomething() const { 
    for (auto& t: ts) { 
     t.doSomething(); 
    } 
} 

template <bool enabled = !std::is_const<T>::value> 
typename std::enable_if<enabled, void>::type 
doSomething() { 
    for (auto& t: ts) { 
     t.doSomething(); 
    } 
} 

它工作正常，但它有一个代码重复。有什么办法可以避免它？

Answer 1

尽管这里不是完美的解决方法：我们有一个非常量成员_doSomething()，其中我们的代码与常量和非常量相同，除了在底层对象上调用的函数之外。由于这个成员是non const我们必须const_castthis从const Foo调用它。

由于_doSomething内部的代码是常量安全的，因此将（const_）强制const远离是安全的。

你的代码也不能编译为const，因为你不能有vector的const。一个向量的元素必须是可分配的，其中const types是通常是不是（它们确实不应该，但是：https://stackoverflow.com/a/17313104/258418）。
您可能需要考虑std::vector<T*>而不是std::vector<T>。 （即存储指针，而不是矢量对象）

#include <iostream> 
#include <vector> 

using namespace std; 

class Bar { 
public: 
    Bar() {} 
    void doSomething() const { 
     std::cout << "const" << endl; 
    } 

    void doSomething() { 
     std::cout << "NON const" << endl; 
    } 
}; 


template <typename T> 
class Foo { 
    void _doSomething() { 
     /*for (auto& t: ts) { 
      t.doSomething(); 
     }*/ 
     test.doSomething(); 
    } 
public: 
    Foo()/*T element) : ts({element})*/ {} 

    template <bool enabled = std::is_const<T>::value> 
    typename std::enable_if<enabled, void>::type 
    doSomething() const { 
     const_cast<typename std::remove_const<Foo<T>>::type*>(this)->_doSomething(); 
    } 

    template <bool enabled = !std::is_const<T>::value> 
    typename std::enable_if<enabled, void>::type 
    doSomething() { 
     _doSomething(); 
    } 
private: 
    //std::vector<T> ts; https://stackoverflow.com/a/17313104/258418 
    T test; 
}; 

int main() 
{ 
    Foo<Bar> nonConstInst; 
    Foo<const Bar> ConstInst; 

    nonConstInst.doSomething(); 
    ConstInst.doSomething(); 
    return 0; 
}