Question

I’m experimenting a little with type traits and template specialization. For example:

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

This works absolutely fine. The goal is to provide a way for users of an interface not to deal with templates and template parameters (Ok, besides using Create()). That is the reason for the typedefs at the bottom of the code.

No here is what I want to achieve next:
cTestClass should have one member variable which is accessible via member functions. Under certain circumstances I either want the user being able to modify the member variable or not to modify the member variable. So basically this means two member functions, one that returns the member as const reference (not modifyable) or non const (modifyable). Problem is, if both those member functions are provided, the user always has the chance to modify the member variable. So I want to choose the appropriate member function during compile time and just provide one correct member function for the user.

The only solution I came up with looks basically like this:

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...

Besides the fact that this really seams to be unnecessary code duplication I always have to specify two typedefs for every possible VALUE. But the user should not be confronted with that choice, he should always be able to just use the types as given above (see 1, 2, 3).

Is this even possible?

I googled a bit and came up with the following site: ACCU:: An introduction to C++ traits.
This explanation seems to a matching blueprint, but I really can’t put the pieces together.
Another possibility I found is described here: C++ Template specialization to provide extra member function? Just adding one function would be possible, but this still doesn’t solve my typedef problem.

Answer 1

We can try to employ 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;

I didn’t try to compile it yet, but the general principle is to prevent one of the functions to compile properly, then, due to the SFINAE principle, the compiler will just throw away the wrong version.