2

我正在尝试一些类型特征和模板专业化。例如：

enum TestEnum
{
    VALUE0 = 0,
    VALUE1 = 1,
    VALUE2 = 2
    //... And so on...
};

template<int Value>
class cTestClass;

//specializations
template<>
class cTestClass<VALUE0>
{
    static int GetVal() { return VALUE0; }
};

template<>
class cTestClass<VALUE1>
{
    static int GetVal() { return VALUE1; }
};

template<>
class cTestClass<VALUE2>
{
    static int GetVal() { return VALUE2; }
};

typedef cTestClass<VALUE0> cClassVal0; //(1)
typedef cTestClass<VALUE1> cClassVal1; //(2)
typedef cTestClass<VALUE2> cClassVal2; //(3)

//Later in the code
template<int Value>
cTestClass<Value>* Create()
{
    return new cTestClass<Value>(/*..*/);
}

//And using the upper function
cClassVal2* pTestClass = Create<VALUE2>();

这绝对没问题。目标是为界面用户提供一种不处理模板和模板参数的方法（好的，除了使用Create()）。这就是代码底部的 typedef 的原因。

不，这是我接下来要实现的目标：cTestClass 应该有一个可以通过成员函数访问的成员变量。在某些情况下，我希望用户能够修改成员变量或不修改成员变量。所以基本上这意味着两个成员函数，一个将成员作为 const 引用（不可修改）或非 const（可修改）返回。问题是，如果提供了这两个成员函数，用户总是有机会修改成员变量。所以我想在编译时选择合适的成员函数，只为用户提供一个正确的成员函数。

我想出的唯一解决方案基本上是这样的：

template<int Value, bool ConstAccess>
class cTestClass;

//specializations
template<>
class cTestClass<VALUE0, true>
{
    const std::string& get() const
    {
        return m_strName;
    }

    static int GetVal() { return VALUE0; }

private:
    std::string m_strName;
};

template<>
class cTestClass<VALUE0, false>
{
    std::string& get()
    {
        return m_strName;
    }

    static int GetVal() { return VALUE0; }

private:
    std::string m_strName;
};

//For every upcoming cTestClass two specializations

typedef cTestClass<VALUE0, true> cConstObjectVal0;
typedef cTestClass<VALUE0, false> cObjectVal0;
//And for the rest...

除了这确实是不必要的代码重复这一事实之外，我总是必须为每个可能的 VALUE 指定两个 typedef。但是用户不应该面临这样的选择，他应该总是能够只使用上面给出的类型（参见 1、2、3）。

这甚至可能吗？

我用谷歌搜索了一下，找到了以下网站：ACCU:: An Introduction to C++ traits。这个解释似乎是一个匹配的蓝图，但我真的无法将各个部分放在一起。我发现的另一种可能性在这里描述：C++ Template specialization to provide extra member function？只添加一个函数是可能的，但这仍然不能解决我的 typedef 问题。

4

1 回答 1

0

我们可以尝试使用SFINAE：

typedef char True;
typedef long False;

template <typename VALUE0, typename IsConst>
class cTestClass
{
public:

    template <typename T, T> struct TypeCheck {};

    const std::string& get(TypeCheck<IsConst, True >* dummy = NULL);
          std::string& get(TypeCheck<IsConst, False>* dummy = NULL);
}

typedef cTestClass<VALUE0, True>  cConstObjectVal0;
typedef cTestClass<VALUE0, False> cObjectVal0;

我还没有尝试编译它，但一般的原则是阻止其中一个函数编译正确，然后，由于SFINAE原则，编译器只会丢弃错误的版本。

于 2012-11-20T15:33:08.957 回答