任何载体的专业化

Question

我想在模板类中为T的不同情况定义一个函数。我的问题是定义T是一个向量（无论它包含什么）的情况。

这是我的第一次尝试之一：

template<typename T>
class Test{
protected:
    T *val;
public:
    Test(T* v):v(val){};
    static string typeName();
};

template<typename T>
string Test<T>::typeName(){
    return "other";
}

template<>
string Test<int>::typeName(){
    return "int";
}

template<typename T>
string Test<vector<T>>::typeName(){
//error: invalid use of incomplete type ‘class Test<vector<T>>’
    return "vector<" + Test<T>::typeName() + ">";
}

我可以通过定义来解决此错误：

template<typename T>
class Test<vector<T>>{
    // ... (the same thing)
}

但我不想这样做，因为我的班级很大，而且我不想再写相同的功能。 如果可能的话，我还想避免让我的类继承自另一个。

通过在这里搜索，我读到了SFINAE，但我是初学者。 我尽力而为，但没有任何效果。 这是另一个尝试：

#include <type_traits>

template<typename T,typename E=void>
class Test{
protected:
    T *val;
public:
    Test(T* v);
    static string typeName();
    static void bidon();
};

template<typename T,typename E>
string Test<T,E>::typeName(){
    return "other";
}

template<>
string Test<int>::typeName(){
    return "int";
}

template<typename T> struct IsVector            : public std::false_type{};
template<typename T> struct IsVector<vector<T>> : public std::true_type {};

template<typename T,typename E>
    string Test<T,typename std::enable_if<IsVector<T>::value,E>::type>::typeName(){
    return "vector<" + Test<typename T::value_type>::typeName() + ">";
}

我有同样的错误。 它出什么问题了 ？ 我想做不可能的事情吗？

Answer 1

我认为你可以用这个达到你想要的效果。 即使方法略有不同，结果也是一样的。

template <typename V>
struct typeName {};

// Handle pointers
template <typename V>
struct typeName<V*> {
    static string name;
};
template <typename V>
string typeName<V*>::name = typeName<V>::name + "*";

template <>
struct typeName<string> {
    static string name;
};
string typeName<string>::name = "string";


template <>
struct typeName<int> {
    static string name;
};
string typeName<int>::name = "int";

template <typename V>
struct typeName<vector<V>> {
    static string name;
};

template <typename V>
string typeName<vector<V>>::name = "vector<" + typeName<V>::name + ">";


template <typename V>
struct typeName<set<V>> {
    static string name;
};

template <typename V>
string typeName<set<V>>::name = "set<" + typeName<V>::name + ">";


int main() {
    cout << typeName<vector<string>>::name << endl;   
    cout << typeName<set<string>>::name << endl;   
    cout << typeName<vector<set<string*>*>>::name;   
}

---

stdout

vector<string>
set<string>
vector<set<string*>*>

Answer 2

由于你的typeName方法既是static又是public ，你可以使用这样的免费助手函数：

template< typename T > struct is_vector : std::false_type {};

template< typename... Ts > struct is_vector<vector<Ts...>> : std::true_type {};

// Standard-confirming compilers will accept the above specialization, but
// if your compiler doesn't like the above, you need to manually provide all
// template arguments to detect std::vector properly:

// template< typename T, typename Allocator >
// struct is_vector<vector<T,Allocator>> : std::true_type {};

template<typename T>
typename std::enable_if< !is_vector<T>::value, string >::type testTypeName(){
    return "other";
}

template<typename T>
typename std::enable_if< is_vector<T>::value, string >::type testTypeName(){
    return "vector<" + Test<typename T::value_type>::typeName() + ">";
}

template<>
string Test<int>::typeName(){
    return "int";
}

template<typename T>
string Test<T>::typeName(){
    return testTypeName<T>();
}

Answer 3

您可以创建一个单独的模板，其中包含该函数，并让主模板调用辅助模板的功能：

template <typename T>
struct tn_helper {
    static string typeName(){
        return "other";
    }
};

template <typename T>
string Test::typeName(){
    return tn_helper<T>::typeName();;
}

template<>
struct tn_helper<int> {
    static string typeName(){
        return "int";
    }
};

template<typename T>
struct tn_helper<vector<T> > {
    static string typeName(){
        return "vector<" + tn_helper<T>::typeName() + ">";
    }
};

// etc.

Answer 4

我不知道为什么你的原始尝试不起作用（就像你希望它编译一样，让我们​​希望其他人可以对此有所了解）但作为一种解决方法，你可以创建一个单独的模板类，它只包含你的静态函数，并在你的主类中使用该类。 有点像：

template<typename T>
struct TypeName {
    static std::string typeName() { return "other"; }
};
template<>
struct TypeName<int> {
    static std::string typeName() { return "int"; }
};
template<typename T>
struct TypeName<std::vector<T>> {
    static std::string typeName() { return "vector<" + TypeName<T>::typeName() + ">"; }
};

template<typename T>
class Test {
public:
    static std::string typeName() { return TypeName<T>::typeName(); }
    // more stuff
};