使用功能模板

Question

我已经创建了不同数据类型的结构，我想返回每种类型的数据。这是否可以使用一个函数模板来完成，该模板采用不包含在结构中或不包含参数的不同数据参数？

我有这样的事情，

struct mystruct{ 
int _int; 
char _c; 
string _str 
}; 

In function template(int i) 
{ 
    mystruct s; 

     switch (getInput) 
    { 
     case 1: 
     return s._int; 
     case 2: 
     return s._c; 
     case 3: 
     return s._str; 
    } 
} 

void main() 

{ 
    int getInput = 1; 
    //pass getInput value to function template 
} 

Answer 1

是：

template<class T> 
T f() { 
    return 0; // for the sake of example 
} 

int main() { 
    return f<int>(); // specify the template parameter 
} 

template<class T> 
vector<T> another_example(); 
// use another_example<int>() which returns a vector<int> 

Answer 2

以下是构建GMAN的（现已删除）你很困惑的问题的解释：

struct some_data 
{ 
    int i; 
    char c; 
    std::string s; 
}; 

template< typename T > struct Getter; 
template<> struct Getter<int> { static int& get(some_data& data) {return data.i} }; 
template<> struct Getter<char> { static char& get(some_data& data) {return data.c} }; 
template<> struct Getter<std::string> { static std::string& get(some_data& data) {return data.s} }; 

template< typename T > 
inline T get(some_data& data) {return Getter<T>::get(data);} 

我不确定。不过，这是否是你要求的。

Answer 3

我的理解如下：我想创建一个函数，其返回类型取决于它的参数。那么，从技术上讲，你不能。

1. 当那些返回类型是具有共同祖先的类时，可以返回一个指向该祖先的指针。这不是一回事，但它有效。不幸的是，两种返回类型是char和int，它们不是首要的类。

2. 当那些返回类型是普通的旧数据类型时，可以返回带标签的联合。不幸的是，其中一种返回类型是std::string，它不是普通的旧数据类型。

3. 解决方案适用于任何类型，但令人难以置信的黑客 - ish是使用void*。那么，不幸的是，void*是容易出错的。如果你使用void*，维护你的代码的人将永远诅咒你。

4. 有效的最终解决方案（双关不打算）是使用boost::variant。这是相当复杂的，但至少它是安全的（不像void*），因为类型错误可以在编译时检查。

Answer 4

这里是另外一个解释，即不使用模板：

struct some_data 
{ 
    int i; 
    char c; 
    std::string s; 

    void get(int& value) const 
     { value = i; } 
    void get(char& value) const 
     { value = c; } 
    void get(& value) const 
     { value = s; } 
}; 

// ... 
some_data received_data; 
int k; 
received_data.get(k); 
//... 
received_data.s = "Hello"; 
std::string world; 
received_data.get(world); 
std::cout << world << std::endl; 

编译器将基于参数的类型的正确方法调用。 这可以被翻译成非成员函数：

void Get_Some_Data(char& value, const some_data& sd) 
{ 
    value = sd.c; 
    return; 
} 


void Get_Some_Data(int& value, const some_data& sd) 
{ 
    value = sd.i; 
    return; 
} 

void Get_Some_Data(std::string& value, const some_data& sd) 
{ 
    value = sd.s; 
    return; 
} 

//... 
char f; 
Get_Some_Data(f, received_data);