Getting non-const type in template

Question

I have a template class that can (and sometimes has to) take a const type, but there is a method that returns a new instance of the class with the same type, but should be explicitly non-const. For example, the following code fails to compile

template<class T> class SomeClass {
public:
    T val;
    SomeClass(T val) : val(val) {}
    SomeClass<T> other() {
        return SomeClass<T>(val);
    }
};

int main() {
    SomeClass<const int> x(5);
    SomeClass<int> y = x.other();
    return 0;
}

because even though there's a copy on val during the constructor, it's copying to the same type - const int. Just like you can distinguish between T and const T in a template, is there a way to distinguish between T and "nonconst T"?

Answer 1

SomeClass<typename std::remove_const<T>::type> other()
{
    return SomeClass<typename std::remove_const<T>::type>(val);
}

std::remove_const is from <type_traits> and is C++11. There's probably a boost::remove_const in Boost.TypeTraits, or you can even roll your own. It's also possible to use std::remove_cv.

Answer 2

You can either use std::remove_const if you are using c++ 11. Otherwise, you can use this:

struct <typename T>
struct remove_const
{
    typedef T type;
};
struct <typename T>
struct remove_const<const T>
{
    typedef T type;
};

Which does the same.