Wrapper for ARGS in a settings manager class about args HOT 2 CLOSED

#include <iostream>
#include <string>

template <typename T>
class eSetting {
};

eSetting<bool> flagA;
eSetting<bool> flagB;
eSetting<bool> flagC;
eSetting<std::string> valueFlagA;
eSetting<std::string> valueFlagB;
eSetting<int> valueFlagC;

template <typename T>
T function(const eSetting<T> &flag) {
    std::cout << "This is the default value" << std::endl;
    return T();
}

template <>
bool function<bool>(const eSetting<bool> &flag) {
    std::cout << "This is the overridden boolean value" << std::endl;
    return true;
}

int main(int argc, char **argv)
{
    function(flagA);
    function(flagC);
    function(valueFlagA);
    function(valueFlagC);
    return 0;
}

#include <iostream>
#include <string>

struct Foo {
    // Enum declaration
    enum class eSetting {
        flagA,
        flabB,
        flagC,
        valueFlagA, // str
        valueFlagB, // str
        valueFlagC // int
    };

    // Return type specializations.  This acts as a compile-time map to map
    // enum values to their return types
    template <eSetting Setting>
        struct eSettingTypes {};

    // Set up get function specializations
    template <eSetting Setting>
        typename eSettingTypes<Setting>::type get();
};

template <>
struct Foo::eSettingTypes<Foo::eSetting::flagA> {
    typedef bool type;
};
template <>
struct Foo::eSettingTypes<Foo::eSetting::valueFlagA> {
    typedef std::string type;
};

template<>
bool Foo::get<Foo::eSetting::flagA>() {
    std::cout << "flagA" << std::endl;
    return true;
}

template<>
std::string Foo::get<Foo::eSetting::valueFlagA>() {
    std::cout << "valueFlagA" << std::endl;
    return "";
}

int main(int argc, char **argv)
{
    Foo foo;
    foo.get<Foo::eSetting::flagA>();
    foo.get<Foo::eSetting::valueFlagA>();
    return 0;
}