C++ те же функциональные параметры с разными типами возврата

Question

Мне нужно найти способ перекомпоновки перегрузки возвращаемого типа функции в C++.

Я знаю, что нет прямого способа сделать это напрямую, но я надеюсь, что вокруг него будет какой-то из коробки. Мы создаем API для пользователей, работающих под ними, и они будут передавать строку данных, которая извлекает значение на основе строковой информации. Эти значения являются разными типами. В сущности, мы хотели бы сделать это:

int = RetrieveValue(dataString1); 
double = RetrieveValue(dataString2); 
// Obviously, since they don't know the type, they wouldn't use int =.... It would be: 
AnotherFunction(RetrieveValue(dataString1)); // param of type int 
AnotherFunction(RetrieveValue(dataString2)); // param of type double 

Но это не работает на C++ (очевидно). Прямо сейчас, мы с его настроить так, что они называют:

int = RetrieveValueInt(dataString1); 
double = RetrieveValueDouble(dataString2); 

Однако мы не хотим, чтобы они должны знать, что тип их строки данных.

К сожалению, нам не разрешено использовать внешние библиотеки, поэтому без использования Boost.

Есть ли способы обойти это?

Просто, чтобы уточнить, я понимаю, что C++ не может изначально сделать это. Но должен быть какой-то способ обойти это. Например, я думал о выполнении RetrieveValue (dataString1, GetType (dataString1)). Это ничего не исправляет, потому что GetType также может иметь только один тип возврата. Но мне нужно что-то подобное.

Я понимаю, что этот вопрос задавали раньше, но в другом смысле. Я не могу использовать какие-либо очевидные ответы. Мне нужно что-то совершенно готовое, чтобы оно мне было полезно, чего не было в ответах в другом вопросе.

Answer 1

Вы имеете, чтобы начать с этого:

template<typename T> 
T RetrieveValue(std::string key) 
{ 
    //get value and convert into T and return it 
} 

Для поддержки этой функции, вы, чтобы работать немного больше для того, чтобы преобразовать значение в тип T. Один простой способ преобразовать значение может быть таким:

template<typename T> 
T RetrieveValue(std::string key) 
{ 
    //get value 
     std::string value = get_value(key, etc); 

     std::stringstream ss(value); 
     T convertedValue; 
     if (ss >> convertedValue) return convertedValue; 
     else throw std::runtime_error("conversion failed"); 
} 

Обратите внимание, что вам все равно придется вызывать эту функцию, как:

int x = RetrieveValue<int>(key); 

Вы могли бы избежать упоминания int в два раза, если вы могли бы сделать это вместо:

Value RetrieveValue(std::string key) 
{ 
    //get value 
     std::string value = get_value(key, etc); 
     return { value }; 
} 

где Value реализуется как:

struct Value 
{ 
    std::string _value; 

    template<typename T> 
    operator T() const //implicitly convert into T 
    { 
     std::stringstream ss(_value); 
     T convertedValue; 
     if (ss >> convertedValue) return convertedValue; 
     else throw std::runtime_error("conversion failed"); 
    } 
} 

Тогда вы могли бы написать это:

int x = RetrieveValue(key1); 
double y = RetrieveValue(key2); 

который, который вы хотите, верно?

Answer 2

К сожалению, нет никакого способа, чтобы перегрузить функцию возвратного типа см этот ответ Overloading by return type

Answer 3

int a=itoa(retrieveValue(dataString)); 
double a=ftoa(retrieveValue(dataString)); 

возвращают строку.

Answer 4

Если вы знаете значение никогда не может быть чем-то вроде нуля или отрицательного, просто возвращает структуру удерживающей Int и дважды и обнулить один вам не нужно ...

Это дешевое и грязные, но легкий путь ...

struct MyStruct{ 
int myInt; 
double myDouble; 
}; 

MyStruct MyFunction(){ 
} 

Answer 5

в качестве альтернативы решению шаблона, вы можете иметь функцию, возвращающую указатель или ссылку на класс, а затем создать подклассы этого класса содержат различные типы данных, которые вы» d хотел бы вернуться. RetrieveValue затем вернет ссылку на соответствующий подкласс.

Это позволило бы пользователю передать возвращенный объект другим функциям, не зная, к какому подклассу принадлежит.

Проблема в этом случае стала бы одним из способов управления памятью - выбор функции, которая распределяет возвращенный объект, и какая функция его удаляет, и когда таким образом мы избегаем утечек памяти.

Answer 6

Единственный разумный способ сделать это - переместить возвращаемое значение в параметры.

void retrieve_value(std::string s, double& p); 
void retrieve_value(std::string s, int& p); 
<...> 

double x; 
retrieve_value(data_string1, x); 

int y; 
retrieve_value(data_string2, y); 

Answer 7

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

int RetrieveValue(const std::string& s, const int&) { 
    return atoi(s.c_str()); 
} 
double RetrieveValue(const std::string& s, const double&) { 
    return atof(s.c_str()); 
} 

int i = RetrieveValue(dataString1, i); 
double d = RetrieveValue(dataString2, d); 

Answer 8

Поскольку вы использовали пример, который был на самом деле не то, что вы хотели, вы бросили все прочь немного.

Установки, которые у вас действительно есть (вызов функции с возвращаемым значением этой функции, тип которой непознаваем, не будет работать, поскольку вызовы функций разрешаются во время компиляции.

Тогда вы ограничены решением для выполнения. Я рекомендую шаблон посетителя, и вам придется существенно изменить свой дизайн, чтобы это изменение изменилось. На самом деле нет другого способа сделать это, что я вижу.

Answer 9

Если данные являются константами времени компиляции (как сказано в ответе на мой комментарий), вы можете использовать магию шаблонов для выполнения задания. Еще более простой вариант - не использовать строки вообще, а некоторые типы данных, которые позволяют вам перегружать аргумент.

struct retrieve_int {} as_int; 
struct retrieve_double {} as_double; 

int RetrieveValue(retrieve_int) { return 3; } 
double RetrieveValue(retrieve_double) { return 7.0; } 

auto x = RetrieveValue(as_int); // x is int 
auto y = RetrieveValue(as_double); // y is double