如何针对模板类中的不同模板参数执行不同的操作？

Question

如果我想创建一个模板类，并根据模板参数的typeid执行不同的操作，那么我该如何编码？

例如，我有以下模板类，其中我想根据它是一个int还是一个字符串来初始化成员字段数据。

#include <string> 

template <class T> 
class A 
{ 
private: 
    T data; 
public: 
    A(); 
}; 

// Implementation of constructor 
template <class T> 
A<T>::A() 
{ 
    if (typeid(T) == typeid(int)) 
    { 
     data = 1; 
    } 
    else if (typeid(T) == typeid(std::string)) 
    { 
     data = "one"; 
    } 
    else 
    { 
     throw runtime_error("Choose type int or string"); 
    } 
} 

但是，此代码不会编译，但具有以下主文件。

#include "stdafx.h" 
#include "A.h" 
#include <string> 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    A<int> one; 
    return 0; 
} 

的错误是：错误C2440： '='：不能从 '为const char [2]' 到 'INT'，这意味着代码转换实际上是检查其他-if语句为一个int，甚至尽管它永远无法达到这部分代码。

接下来，按照这个例子（Perform different methods based on template variable type），我尝试了下面的A.h文件，但是我有几个链接器错误提到A（void）已经在A.obj中定义。

#include <string> 

template <class T> 
class A 
{ 
private: 
    T data; 
public: 
    A(); 
    ~A(); 
}; 

// Implementation of constructor 
template <> 
A<int>::A() 
{ 
    data = 1; 
} 
template <> 
A<std::string>::A() 
{ 
    data = "one"; 
} 

有没有人知道如何让这段代码启动并运行？我也意识到，在模板类中使用这样的if-else语句可能会从模板中删除权力。有没有更好的方法来编码？

编辑：

#pragma once 

#include <string> 

// Class definition 
template <class T> 
class A 
{ 
public: 
    A(); 
    ~A(); 
private: 
    T data; 
}; 

// Implementation of initialization 
template < class T > 
struct initial_data 
{ 
    static T data() { throw runtime_error("Choose type int or string"); } 
}; 

template <> 
struct initial_data<int> 
{ 
    static int data() { return 1; } 
}; 

template <> 
struct initial_data<std::string> 
{ 
    static std::string data() { return "one"; } 
}; 

// Definition of constructor 
template <class T> 
A<T>::A() 
    : data(initial_data<T>::data()) 
{ 
} 

和以下主要：

#include "stdafx.h" 
#include "A.h" 
#include <string> 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    A<int> ione; 

    return 0; 
} 

链接器错误我现在得到的是：与托斯滕（如下图），我现在有以下阿文件的讨论后测试模板4.obj：错误LNK2019：函数_wmain中引用的无法解析的外部符号“public：__thiscall A ::〜A（void）”（?? 1？$ A @ H @@ QAE @ XZ）

Answer 1

显式特化是要走的路。

我假设你将A.h包含在几个.cpp文件中，这就是问题的根本原因。

专业化是定义，并且A :: A（）和A :: A（）只能有一个定义，所以它们只能在一个.cpp中定义。

你必须在阿移动明确的专业化一个.cpp

template <> 
A<int>::A() 
{ 
    data = 1; 
} 
template <> 
A<std::string>::A() 
{ 
    data = "one"; 
} 

，并保持一个声明为他们

template<> A<int>::A(); 
template<> A<std::string>::A(); 

，这样编译器知道他们是专门明确和没有按不要尝试添加自动的。

编辑：用这四个文件，g ++ m.cpp f.cpp a.cpp不显示任何错误。

// a.h 
#define A_H 

#include <string> 

template <class T> 
class A 
{ 
private: 
    T data; 
public: 
    A(); 
}; 

template<> A<int>::A(); 
template<> A<std::string>::A(); 

#endif 

// a.cpp 
#include "a.h" 

template <> 
A<int>::A() 
{ 
    data = 1; 
} 
template <> 
A<std::string>::A() 
{ 
    data = "one"; 
} 

// f.cpp 
#include "a.h" 

int f() 
{ 
    A<int> one; 
    A<std::string> two; 
} 

// m.cpp 
#include "a.h" 

int f(); 

int main() 
{ 
    A<int> one; 
    A<std::string> two; 
    f(); 
} 

Answer 2

在情况下，它只是要具有行为依赖于T的c'tor，我会建议考虑此因素出不同的结构：如果你专注一类

template < class T > 
struct initial_data 
{ 
    static T data() { throw runtime_error("Choose type int or string"); } 
}; 

template <> 
struct initial_data<int> 
{ 
    static int data() { return 1; } 
} 

template <> 
struct initial_data<std::string> 
{ 
    static std::string data() { return "1"; } 
} 

在它的模板参数上，不同的专业化是完全不同的类型，可以有不同的数据和功能集。

最后：

template <class T> 
A<T>::A() 
    : data(initial_data<T>::data()) 
{ 
} 

亲切的问候 托斯滕

Answer 3

你是第二个解决方案是正确的，你需要的是模板特（保持政治宣言和执行一起）：

#include <string> 

template <class T> 
class A 
{ 
private: 
    T data; 
public: 
    A(); 
    ~A(); 
}; 

template <> 
class A <std::string> 
{ 
private: 
    std::string data; 
public: 
    A() { data = "one"; } 
}; 

template <> 
class A <int> 
{ 
private: 
    int data; 
public: 
    A() { data = 1; } 
}; 

如果我可能会建议更优雅的解决方案，那么我会向构造函数添加一个参数并避免模板特化：

template <class T> 
class A 
{ 
private: 
    T data; 
public: 
    A(T value) : data(value) {} 
    virtual ~A() {} 
};