Изменение типа возврата функции без шаблонной специализации. C++

К сожалению, это невозможно. В C ++ невозможно перегрузить функцию на основе ее возвращаемого значения. У вас либо должно быть 3 функции: ParseInt, ParseFloat и ParseBool, либо использовать шаблон функции.

Я бы согласился с литбом, который был немного быстрее меня. Используйте операторы приведения.

#include <iostream>
#include <string>
#include <sstream>

class Convertible
{
public:
    int m_Integer;
    bool m_Bool;
    double m_Double;

    Convertible() : m_Integer(0), m_Bool(false), m_Double(0.0) {};

    operator int() const
    {
        return m_Integer;
    }
    operator bool() const
    {
        return m_Bool;
    }
    operator double() const
    {
        return m_Double;
    }
};

Convertible parse(std::string data)
{
    Convertible l_result;

    std::istringstream converter(data);
    converter >> l_result.m_Integer;

    std::istringstream converter2(data);
    converter2 >> l_result.m_Bool;

    std::istringstream converter3(data);
    converter3 >> l_result.m_Double;

    return l_result;
}

void main()
{
    int l_convertedInt = parse("2");
    bool l_convertedBool = parse("true");
    double l_convertedDouble = parse("3.14");

    std::cout << "Converted '2' to " << l_convertedInt << std::endl;
    std::cout << "Converted 'true' to " << l_convertedBool << std::endl;
    std::cout << "Converted '3.14' to " << l_convertedDouble << std::endl;
}

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

template<typename T> T parse(const string& str) { /* do stuff for other types */ }
template<> int parse<int>(const string& str) { /* do stuff for ints */ }
template<> double parse<double>(const string& str) { /* do stuff for doubles */ }
template<> bool parse<bool>(const string& str) { /* do stuff for bools */ }
// etc.

А затем вызывать как

int value = parse<int>("37");
double value = parse<double>("3.14");
bool value = parse<bool>("true");

Если вы уже знали это, просто проигнорируйте этот ответ, но из вашего вопроса не ясно, знаете ли вы, что это возможно.

Конечно, если то, что вы делаете, не

Вы можете передать свой выходной аргумент как указатель или ссылку.

Примерно так:

template<class T> void parse(const std::string &input, T& output);

Затем введите такой код:

double d; parse(input, d);
int i; parse(input, i);

должен работать.

Однако ваш код выглядит как идеальный вариант для std :: istringstream, который был бы просто:

istringstream is(input);
input >> d;

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

Тогда это могло быть так:

istringstring is(input);
input >> LineExtracter(x, y, d);

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

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

Вы можете вернуть void * и затем привести результат по мере необходимости.

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