Question

我有兴趣设计一个模板接口，其中函数的常量和返回类型本身会根据模板参数而改变。我已设法为返回类型执行此操作，如下所示。

template<typename T, bool canChange>
struct Changable{};

template<typename T>
struct Changable<T,true>
{
    typedef T type;
};

template<typename T>
struct Changable<T,false>
{
    typedef const T type;
};

template<typename T, bool canChange>
struct Data{
    typedef typename Changable<T,canChange>::type DataType;        
    DataType m_data; //< This makes it const/non-const at compile time.

    // This function will also make the return type const/non-const 
    // at compile time. 
    DataType& GetDataRef(){ return m_data;} 

    //However, it seems to me that I still need a second function 
    //with an explicit "const", which I can't seem to avoid.
    DataType& GetDataRef()const{return m_data;}
};

我可以在编译时使用一些SFINAE魔法以某种方式避免在这里使用两个const /非const函数吗？ std :: enable_if在这里是理想的，但在我看来，const不是一种类型，这种方法可能不起作用。有什么建议吗？

Answer 1

以下是基于继承的示例：

#include <type_traits>
#include <iostream>

template<typename T, bool canChange>
struct Changable { using type = const T; };

template<typename T> 
struct Changable<T, true> { using type = std::decay_t<T>; };

template<typename, typename, bool>
struct Base;

template<typename D, typename T>
struct Base<D, T, true> {
    using DataType = typename Changable<T, true>::type;
    DataType& GetDataRef() { std::cout << "non-const" << std::endl; return static_cast<D*>(this)->m_data; }
};

template<typename D, typename T>
struct Base<D, T, false> {
    using DataType = typename Changable<T, false>::type;
    DataType& GetDataRef() const { std::cout << "const" << std::endl; return static_cast<const D*>(this)->m_data; }
};

template<typename T, bool canChange>
struct Data: Base<Data<T, canChange>, T, canChange> {
    friend class Base<Data<T, canChange>, T, canChange>;
    typename Base<Data<T, canChange>, T, canChange>::DataType m_data{};
    using Base<Data<T, canChange>, T, canChange>::GetDataRef;
};

int main() {
    Data<int, true> d1;
    Data<int, false> d2;
    d1.GetDataRef();
    d2.GetDataRef();
}

根据要求，Data只有GetDataRef方法的一个定义哪一个可用，const一个或另一个，取决于canChange的值。

请注意friend声明。它允许基类访问Data。

的私有数据成员

Answer 2

我想我会使用标准库中已有的模板来解决这个问题。它不需要继承或任何自定义类。

#include <utility>

template<typename T, bool canChange>
struct Data{
    using value_type = T;
    using cv_type = std::conditional_t<canChange, value_type, std::add_const_t<value_type>>;
    using reference = std::add_lvalue_reference_t<cv_type>;
    using const_reference = std::add_lvalue_reference_t<std::add_const_t<cv_type>>;

    Data(T t) : m_data(std::move(t)) {}

    cv_type m_data; //< This makes it const/non-const at compile time.

    // This function will also make the return type const/non-const
    // at compile time.
    reference GetDataRef(){ return m_data;}

    //However, it seems to me that I still need a second function
    //with an explicit "const", which I can't seem to avoid.
    const_reference GetDataRef() const {return m_data;}
};

int main()
{
    Data<int, true> d1 { 10 };
    d1.m_data = 12;
    const Data<int, true>& rd1 = d1;

    auto& a = d1.GetDataRef();
    auto& b = rd1.GetDataRef();
    a = 12;  // compiles fine
//    b= 12; won't compile

    Data<int, false> d2 { 10 };
    const Data<int, false>& rd2 = d2;

    auto& c = d2.GetDataRef();
    auto& d = rd2.GetDataRef();
//    c = 12;  // won't compile
//    d = 12;  // won't compile

}

现在问题：

我可以在编译时使用某些SFINAE魔法以某种方式避免在这里使用两个const /非const函数吗？

你几乎在这里回答你自己的问题。 SFINAE要求在直接上下文中考虑模板参数。这是一种复杂的说法，std::enable_if<>中的表达式必须依赖于某些模板类型。

不幸的是，在评估函数GetDataRef时，T的模板类型是已知的，因此enable_if将无法帮助我们。

因此，如果我们只需要GetDataRef的一个版本，我们确实不得不求助于模板类型的派生（然后基本类将在T的直接上下文中进行评估）。

然而，即便如此，也存在问题。

考虑：

Data<int, true>& x这是对包含可变数据的可变容器的引用
const Data<int, true>& y这是对包含可变数据的不可变容器的引用

调用x.GetDataRef()应该返回一个int的可变引用，否则我们会混淆我们的用户。

调用y.GetDataRef()当然应该返回一个对int的const引用，否则用户可能会惊讶地发现const事件的成员实际上是可变的。

Answer 3

也许这样的事情可以解决问题：

#include <type_traits>
#include <iostream>

template<typename T, bool canChange>
struct Changable: std::false_type { using type = const T; };

template<typename T>
struct Changable<T, true>: std::true_type { using type = std::decay_t<T>; };

template<typename T, bool canChange>
struct Data {
    using DataTraits = Changable<T, canChange>;

private:
    template<typename U>
    std::enable_if_t<U::value, typename U::type&>
    GetDataRefImpl() { std::cout << "non const" << std::endl; return m_data; }

    template<typename U>
    std::enable_if_t<not U::value, typename U::type&>
    GetDataRefImpl() const { std::cout << "const" << std::endl; return m_data; }

public:
    typename DataTraits::type m_data{};

    typename DataTraits::type& GetDataRef() { return GetDataRefImpl<DataTraits>(); }
    typename DataTraits::type& GetDataRef() const { return GetDataRefImpl<DataTraits>(); }
};

int main() {
    Data<int, true> d1;
    Data<int, false> d2;
    d1.GetDataRef();
    d2.GetDataRef();
}

基本思想是让类暴露这两个函数，然后将它们内部转发到同一个 sfinae d const或non-const（这取决于关于canChange）的价值正如您通过运行示例所看到的，结果是：

非const
常量

即使d1和d2都被定义为非常量，也是如此 std::enable_if在编译时打开右内部函数。

请注意，我使用了C ++ 14提供的内容（例如std::enable_if_t）该示例可以很容易地转换为基于（std::enable_if_t只不过typename std::enable_if<condition, type>::type等等）的C ++ 11。

Answer 4

如果您可以使用C ++ 17，请查看is_const，add_const和remove_const。与if constexpr ()一起，应该有一个相当优雅的解决方案。

c ++用于更改函数常量的模板

4 个答案: