Использование шаблонов функций

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

Я понимаю следующее: я хочу создать функцию, тип возвращаемого значения которой зависит от ее параметров. Ну, технически, вы не можете.

1. Когда эти возвращаемые типы являются классами с общим предком, вы можете вернуть указатель на этого предка. Это не совсем то же самое, но это работает. К сожалению, два типа возврата - char и int, которые не являются классами на первом месте.

2. Когда эти возвращаемые типы являются простыми старыми типами данных, вы можете вернуть теговое объединение. К сожалению, одним из возвращаемых типов является std::string, который не является простым старым типом данных.

3. Решение, которое работает с любым типом, но невероятно хакерское, заключается в использовании void*. Ну, к сожалению, void* подвержен ошибкам. Тот, кто поддерживает ваш код, будет проклинать вас вечно, если вы используете void*.

4. Окончательное решение (каламбур не предназначен), которое работает, состоит в использовании boost::variant. Это довольно сложно, но, по крайней мере, безопасно (в отличие от void*), потому что ошибки типа можно проверить во время компиляции.

Answer 3

Ниже приводится построение интерпретации 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 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);