Is there have a way to delay type binding at code level in C++?

Question

I'm going to request some user configuration via json from the server that contains two types of data like (usrID, bool), and (usrID, int). so, I created two map to classify and reload two functions with the same name to put the data into the corresponding map after parsed.

For the sake of refinement, I used the auto keyword of C++11 to initialize a variable without assign and determined its type whether bool or int mentioned above through assigned by parse function, so as to call the overloaded function directly to store them. But it causes compiler error that cannot use a auto variable without assign.

bool fromStringtoBool() {……}
int  fromStringtoInt() {……}

void setAppidConfig(int,bool);
void setAppidConfig(int,int);
……
……
void main func()
{
    ……
    int usrId;
    auto value;
    if(isBool())
    {
       value = fromStringtoBool();
    }
    else
    {
       value = fromStringtoInt();
    }

    setAppidConfig(usrId,value)
    ……
}

Is it possible to implement the above logic in C++ ?

Answer 1

auto allows you to omit the type name and let the compiler deduce the type. There is no type to deduce from in your case, since there's no assignment, so nothing can be deduced.

For your use case, you need some kind of variant type that can store one of several types. The Qt library has QVariant, and other libraries usually offer something like that as well. As of C++17 however, such a type is offered directly by the standard library: std::variant.

int usrId;
std::variant<bool, int> value;

if (isBool()) {
   value = fromStringtoBool();
} else {
   value = fromStringtoInt();
}

setAppidConfig(usrId, value);

The setAppidConfig() function would need to accept an appropriate variant parameter:

void setAppidConfig(int usrId, std::variant<bool, int> value)
{
    // ...

    if (std::holds_alternative<int>(value)) {
        // It's a int.
        int i = std::get<int>(value);
    } else {
        // It's a bool.
        bool b = std::get<bool>(value);
    }
}

Note that variants can hold more than just two types (you can have an std::variant<bool, int, std::string> for example.)

If you need something that can hold anything, then you can use an std::any. This type does not need to know the types in advance (it takes no template arguments.)