将具有不同模板参数的类实例保存在一个矢量中，但保留其属性

Question

I would like to have a program that parses and manages command-line parameters for me. As you can see in the main -function, by using simple commands like Option<int>("number", { "-n", "--number" }) you can specify the type the option's value should have (like int in this case), an unique identifier for each option (like "number" ), and multiple strings this option can be introduced with. Also, many options should be wrapped in a class called OptionSet , which simplifies access to its options.

But in my actual code, I am having several problems right now:

1. I want to store multiple instances of one class with different template parameters within one std::vector . For example, in my code, Option<int> should be stored in the same vector like Option<std::string> and Option<double> .
   Maybe it's even possible to store the template parameters separately in another vector?
2. By using using , std::enable_if_t and std::is_same I created a type called OptionHasValue . If the template parameter Invert is false and T is void , OptionHasValue has an invalid type, otherwise it has the type specified by the template parameter U .
   The class OptionValue uses OptionHasValue and a bit of SFINAE magic to decide if it should have the needed methods for supporting the storage of values or not. That is, the first version of OptionValue has OptionHasValue<T> as its second template parameter, so it becomes invalid (and removed by the compiler) if T is void . The other version of OptionValue has the opposite behavior, because its second template parameter is OptionHasValue<T, true> and the true inverts the behavior of OptionHasValue .
   The class Option itself inherits from OptionValue , so if you create an option like Option<void> , it does not have support for values (that is, it lacks functions like setValue , setValueFromString and getValue as it should). On the other hand, if you create an option like Option<int> , the resulting class instance has all of these features.
   The problem now is, that (for example) OptionSet::process() accesses both Option::hasValue and Option::setValueFromString , but the latter is only declared if Option::hasValue is true (and the corresponding template parameter for the option is not void ). But because Option::setValueFromString is not wrapped in some kind of template here, the compiler also complains.
3. In my main -function I use the function optionSet.getOptionValue(std::string) . This function should return the value of an option (after it has been set after process() has been called). The difficult thing now is that the return type depends on the return value of findOptionByIdentifier , a function which loops through all available options and returns the option with the wanted identifier.
   For example, if identifier would be "number" (as in the example for an Option at the beginning of this question), the return type of findOptionByIdentifier would be Option<int> , because the only option having the identifier "number" is the one which has int as its first template parameter, which would finally result in getOptionValue having the return type int .
   You can see the expected behavior in comments in some of the last lines of the main -function.

So, what do I have to change in the following code to fix all these things (and to make it compile)? I am using g++ 5.2.0 (mingw-w64), so I may use any feature of C++11 and C++14.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <stdexcept>
#include <type_traits>
#include <boost/lexical_cast.hpp>
#include <boost/any.hpp>



template<typename T, bool Invert = false, typename U = void>
using OptionHasValue = std::enable_if_t<(!std::is_same<T, void>::value) ^ Invert, U>;       //only make this template substitution successful, if (when 'Invert' is false) T is not if type 'void'

template<typename T, typename Enable = void>
class OptionValue;

template<typename T>
class OptionValue<T, OptionHasValue<T>>             //using SFINAE ("substitution failure is not an error") here
{
    protected:
        T                               value;

    public:
        void setValue(T newValue)
        {
            value = newValue;
        }

        void setValueFromString(std::string newValueStr)
        {
            setValue(boost::lexical_cast<T>(newValueStr));
        }

        T getValue()
        {
            return value;
        }

        bool hasValue()
        {
            return true;                            //if this class variant is taken by the compiler, the 'Option' that will inherit from it will have a value
        }
};

template<typename T>
class OptionValue<T, OptionHasValue<T, true>>       //the opposite condition (the 'true' inverts it)
{
    //option value is disabled, but to check if a value is available in the derived class, add a function for that (or should I not?)
    public:
        bool hasValue()
        {
            return false;
        }
};



template<typename T>
class Option : public OptionValue<T>
{
    private:
        std::string                     identifier;
        std::vector<std::string>        variants;

    public:
        Option(std::string newIdentifier, std::vector<std::string> newVariants)
        {
            identifier = newIdentifier;
            variants = newVariants;
        }

        bool hasVariant(std::string v)
        {
            return (std::find(variants.begin(), variants.end(), v) != variants.end());
        }

        std::string getIdentifier()
        {
            return identifier;
        }
};



class OptionSet
{
    private:
        std::vector<boost::any>         options;                                //boost::any can't be the right way to do this, or is it?
        std::vector<std::string>        argvVec;

        template<typename T>
        Option<T>& findOptionByIdentifier(std::string identifier)
        {
            for(auto& o : options)
                if(o.getIdentifier() == identifier)                             //of course this doesn't compile, because 'o' will always be of type 'boost::any', but what should I do instead?
                    return o;
            throw std::runtime_error("error: unable to find option by identifier \"" + identifier + "\"\n");
        }

        template<typename T>
        Option<T>& findOptionByVariant(std::string variant)
        {
            for(auto& o : options)
                if(o.hasVariant(variant))                                       //probably almost the same compile error like in 'findOptionByIdentifier'
                    return o;
            throw std::runtime_error("error: unable to find option by variant \"" + variant + "\"\n");
        }

    public:
        template<typename t>
        void add(Option<T> opt)
        {
            options.push_back(opt);                                             //is this the right way to add instances of classes with different template parameters to a vector?
        }

        void setArgvVec(std::vector<std::string> newArgvVec)
        {
            argvVec = newArgvVec;
        }

        void process()
        {
            for(size_t i=0; i<argvVec.size(); i++)
            {
                Option<T>& opt = findOptionByVariant(argvVec[i]);               //of course this doesn't compile either, but what should I do instead?
                if(opt.hasValue())
                {
                    if(i == argvVec.size()-1)
                        throw std::runtime_error("error: no value given for option \"" + argvVec[i] + "\"\n");
                    opt.setValueFromString(argvVec[i]);                         //boost::bad_lexical_cast should be caught here, but that's not important right now
                    i++;
                }
            }
        }

        template<typename T>
        T getOptionValue(std::string identifier)
        {
            Option<T>& opt = findOptionByIdentifier(identifier);                //a bit like the call to 'findOptionByVariant' in 'process()'. also, this variable does not have to be a reference
            if(!opt.hasValue())
                throw std::runtime_error("error: option with identifier \"" + identifier + "\" has no value\n");
            return opt.getValue();
        }
};



int main()
{
    OptionSet optionSet;

    //it's not guaranteed that OptionSet::add will always receive a rvalue, I just do it here for shorter code/simplicity
    optionSet.add(Option<void>("help", { "-?", "--help" }));                    //if it's a void-option, the 'Option' does not have a value, if the template parameter is anything else, it has one (like below)
    optionSet.add(Option<std::string>("message", { "-m", "--message" }));
    optionSet.add(Option<int>("number", { "-n", "--number" }));
    optionSet.add(Option<double>("pi", { "-p", "--pi" }));

    optionSet.setArgvVec({ "--help", "-m", "hello", "--number", "100", "--pi", "3.14" });
    optionSet.process();

    std::string message = optionSet.getOptionValue("message");
    int number = optionSet.getOptionValue("number");
    double pi = optionSet.getOptionValue("pi");

    std::cout << "Message: " << message << "\n";        //should output 'hello'
    std::cout << "Number:  " << number << "\n";         //should output '100'
    std::cout << "Pi:      " << pi << "\n";             //should output something like '3.140000'

    return 0;
}

Answer 1

I am not sure I fully understood the question, but I will try to answer it.

I want to store multiple instances of one class with different template parameters

There is no such thing. A template with different template paramter is a different class. However, you seem to be solving it successfully through boost::any . You could also use another type-erasure technique - for example, have a non-template parent to all your options, or switch to non-type-erasure boost::variant , as it seems like you only have a limited number of possible option types.

By using using, std::enable_if_t and std::is_same I created a type called OptionHasValue...

First of all, I would not use SFINAE in this example. Simple partial specialization will suffice. As for opt.setValueFromString(argvVec[i]); just create a NOOP function in void option class.

As for the last question, just use a templated function which receives a reference to the return type, instead of returning it.