Ytukyg

Is there any way (conventional or no) to get a choice between multiple specified return types from a function. For example:

/* Concept code... */

class var {

    public:

        union {

            bool _bool;

            int _int;

            char* _char_pointer;

        } primitive_value;

        std::string type;



        var(bool arg) { primitive_value._bool = arg; type = "bool"; }

        var(int arg) { primitive_value._int = arg; type = "int"; }

        var(char* arg) { primitive_value._char_pointer = arg; type = "char*"; }



        // Function/ method that could return `bool`, `int` or `char*`

        <bool, int, char*> valueOf() const {

            if (type == "bool") return primitive_value._bool;

            else if (type == "int") return primitive_value._int;

            else if (type == "char*") return primitive_value._char_pointer;

        }

};

There is a reference to a similar question here I've seen that suggested using void* pointers or union's but I have yet to fully understand how those work.

No container types (such as std::any, std::optional, std::variant) are allowed because I want to know if there is an alternative to those as well.

To add on, this is all in the name of curiosity. Currently I am searching the optional and variant header files to know how the feature I'm asking for was implemented but no luck so far.

I'm hoping the platform here could have a practical solution to this potential problem.

You can use a mix of template function and if constexpr (C++17):

template<typename T>

T valueOf() const {

    if constexpr(std::is_same<T, bool>) return _boolValueOf();

    else if constexpr(std::is_same<T, int>) return _intValueOf();

    else if constexpr(std::is_same<T, std::string>) return _std_stringValueOf();

}

Requires passing the type, but then the signature could be:

template<typename T>

T valueOf(const T& d) const {

    if constexpr(std::is_same<T, bool>) return _boolValueOf(d);

    else if constexpr(std::is_same<T, int>) return _intValueOf(d);

    else if constexpr(std::is_same<T, std::string>) return _std_stringValueOf(d);

}

High-level and recomended solution is std::any, std::variant, std::optional. Low-level, hackish dangerous, final solution is union, void*, static_cast...
If you want neither, there is no more left to try. Do you finally want to do it in C++?

If are interested in the implementation of those high-level facilities, you can check the source code on open source implementations. But you will eventually find that those implementations device the low level constructs pointed above.

First to have different return types you need to use a template to differentiate the functions. Then you can call var(true).valueOf<bool>() for example. You will have to specify the template on every call so the compiler knows what function (and return type) to use. This can't be deduced on it's own.

Secondly the var.type is a string that can only be checked at runtime. So var(42).valueOf<bool>() compiles just fine. You would have to check var.type against the template argument at runtime and throw an exception when the types don't match.

Not an ideal design.

For you valueOf function, imo, user-defined conversion is also a choice:

operator std::string()

    {

        return primitive_value._char_pointer;

    }

    operator bool()

    {

        return primitive_value._bool;

    }

    operator int()

    {

        return primitive_value._int;

    }

    ......

Then you can use like this:

var v1("hello");

var v2(true);

var v3(10);

std::string a = v1;

bool b = v2;

int c = v3;



std::cerr << static_cast<std::string>(v1) << 'n';

std::cerr << std::boolalpha << static_cast<bool>(v2) << 'n';

std::cerr << static_cast<int>(v3) << 'n';

If you still hope to use function, just add a operator():

var

operator()()

{

    return *this;

}

Then you can:

var v1("hello");

var v2(true);

var v3(10);

std::string a = v1();

bool b = v2();

int c = v3();

But still a little ugly, right? Just add your valueOf function:

var

valueOf()

{

    return *this;

}

Then:

var v1("hello");

var v2(true);

var v3(10);

std::string a = v1.valueOf();

bool b = v2.valueOf();

int c = v3.valueOf();

But these solutions have many limitions. if constexpr provided by Matthieu Brucher is more powerful. Just all about provide a idea here : ).
But please note, unlike if constexpr, the ways I provided is not really multiple types return, just user-defined conversion.

Of course, there are more solutions, like sfinae(use enable_if and is_same in return type), or tag dispatch, but both of them require template