Generic parameter checker in C++

Question

I am working on a generic parameter checker in C++ that can add options and parse their content.

Here is my Param class:

class Param
{
public:
  Param();
  ~Param();

  template <typename T>
  void  add_option(std::string, std::string, T&); // flag, description, storage value

protected:
  std::map<std::string, IOption> options;
};

template <typename T>
void    Param::add_option(std::string, std::string, T&) // Is templated to add an option depending on its type
{}

template<> void Param::add_option<int>(std::string, std::string, int &);
template<> void Param::add_option<std::string>(std::string, std::string, std::string &);

As you can see I wish to store up new options in a map, here is the class Option and it's "interface":

template <typename T>
class Option : public IOption
{
public:
  Option(std::string flag, std::string desc, T &ref) : flag_(flag), desc_(desc), ref_(ref) {}
  ~Option() {}

  std::string getFlag()
  {
    return (flag_);
  }

protected:
  std::string   flag_;
  std::string   desc_;
  T             &ref_;
};

class IOption
{
public:
  virtual ~IOption() {}
  IOption() {}

  virtual std::string getFlag() = 0;
};

The reason why I have created this interface is to store up my options in the map even though they are templated.

But right now, I can't compile because

field type 'IOption' is an abstract class

What would be the best way to create a generic parameter checker from what I have in C++?

Store pointers of IOption ? std::map More info here http://stackoverflow.com/questions/15188894/why-doesnt-polymorphism-work-without-pointers-references — SnoozeTime, Jun 21 '16 at 08:31
@SnoozeTime, or even better [smart pointers](http://en.cppreference.com/w/cpp/memory/unique_ptr) — StoryTeller - Unslander Monica, Jun 21 '16 at 08:34

user2807083 · Accepted Answer · 2016-06-21T08:42:00.740

3

You can't store instance of abstract class. You should use pointer or smart pointer and change options declaration like this:

std::map<std::string, IOption*> options;

or

std::map<std::string, std::unique_ptr<IOption> > options;

or

std::map<std::string, std::shared_ptr<IOption> > options;

edited Jun 21 '16 at 08:42

answered Jun 21 '16 at 08:36

user2807083

2,962
4
29
37

2

Unless something is being shared, don't jump the gun and use a `shared_ptr`, it has overhead you don't need. – StoryTeller - Unslander Monica Jun 21 '16 at 08:37
@StoryTeller, yes, but `std::unique_ptr` will be hard to use in this context for beginner – user2807083 Jun 21 '16 at 08:38
3

Not really more difficult. The standard containers are quite adapt at storing `std::unique_ptr`. The committee didn't overlook that. – StoryTeller - Unslander Monica Jun 21 '16 at 08:40

score 1 · Answer 2 · answered Jun 21 '16 at 08:42

1

The map class needs to allocate storage for the key / value pairs you add to it. By definition you can't instantiate an instance of an abstract class, so the storage size cannot be determined.

So yes, store pointers or smart pointers to IOption.

answered Jun 21 '16 at 08:42

dtopham75

620
6
14

Generic parameter checker in C++

2 Answers2