Btukfyl

I'm trying to create a function which return type should depend on switch statement, something like:

auto function_name (int value) {

    switch (value) {

        case 1 : {return 2.3;}

        case 2 : {return 1;}

        case 3 : {return "string";}

    }

}

But I can't because of an error:

error: inconsistent deduction for auto return type: 'double' and then 'int'

What can I do to create something similar by functionality to the example above?

A function in C++ can only have a single type that it returns. If you use auto as the return type and you have different return statements that return different types then the code is ill-formed as it violates the single type rule.

This where std::variant or std::any needs to be used. If you have a few different types that could be returned via some run-time value then you could use either of those types as "generic type". std::variant is more restrictive as you have to specify the types it could be, but it also less expensive then std::any because you know what types it could be.

std::variant<double, int, std::string> function_name (int value) {

    using namespace std::literals::string_literals;

    switch (value) {

        case 1 : {return 2.3;}

        case 2 : {return 1;}

        case 3 : {return "string"s;} // use ""s here to force it to be a std::string

    }

}

Will let you return different types.

If the function argument is known at compile time, you can use a compile time dispatch like e.g.

template <int N>

constexpr auto function_name()

{

   if constexpr(N == 1)

      return 2.3;

   else if constexpr (N == 2)

      return 1;

   else

      return "string";

}

which can be instantiated and invoked as follows

std::cout << function_name<1>() << "n";

C++17 is necessary for the if constexpr part. Note that when binding the return value to a variable, carefully choose the type (e.g. to not implicitly convert a double to an int by accident), use type deduction or a variant-type as shown in the existing answers.

Note that as @NathanOliver pointed out in the comments, there is also a pre-C++17 solution that uses template specialization instead of if constexpr:

template <int N> constexpr auto function_name() { return "string"; }

template <> constexpr auto function_name<1>() { return 2.3; }

template <> constexpr auto function_name<2>() { return 1; }

The usage of this template and its specializations does not differ from the above.

The error message says it all: all branches of the function must return the same type. This limitation is not specific to auto return type.

One possible fix:

std::variant<double, int, std::string> function_name(int value) {

    switch(value) {

    case 1 : return 2.3;

    case 2 : return 1;

    case 3 : return "string";

    default: throw;

    }

}

Alternatively, you can use boost::variant.