C++ Make a generic interface

Question

I have an Interface (there missing a lot of members, but mind the fact this interface is mandatory). I will need 5 classes inheriting from it, which will have a _value attribute. So, ins\ tead of implement 5 classes(for char, short, int, float, double), I thought about a template class :

class my_interface
{
public:
    virtual [various_types]    getValue() const = 0;
};

template<typename T>
class my_class : public my_interface
{
private:
    T    _value;
public:
    my_class(T value) : _value(value) {} // initialize the attribute on construct
    virtual T        getValue() const { return _value; }
};

...so that something like that could work :

void                my_function()
{
    my_inteface*    a = new my_class<char>(42);
    my_interace*    b = new my_class<short>(21);
    int             result;

    result = a->getValue() + b->getValue();
}

But I don't see how I could do. It seems you can't make templates on interface pure virtual. To me, the only way that could work would be to make getValue() to always return a double, since it is the highest sized type I need. However, I don't like that solution.

Answer 1

If you have just one methods (getValue()) on your interface then you only need the template class implementation.

However if you want to an interface like this:

std::string getValue();
int getValue();
long getValue();

Then you are out of luck as you cannot overload a function name based only on the return type. Alternatively you could create a wrapper type.

EDIT

By wrapper type what I mean is that if getValue is required to return multiple types you could do it in a number of ways using a wrapper class that encapsulates your required functionality rather than add it to your top level interface. It could look something like this:

enum ValType{
  INT, CHAR, STR, DEQUE
};

class Wrapper{
private:
  union S{
    int intVal;
    char charVal;
    std::string stringVal;
    std::deque dequeVal;
    ~S() {}
  } theVal;

  ValType heldType;
public:
  void setVal(int value){ heldType = INT; theVal.intVal = value; }
  void setVal(char value){ heldType = CHAR; theVal.charVal = value; }
  // ... and so on
  int getIntVal() const {
    if(heldType!=INT) 
      throw std::runtime_error("Cop on");
    return theVal.int;
  }
  // and so on
}

Then your interface is

public class my_interface{
  virtual Wrapper getVal();
}

You are not really gaining much here as the user will still have to call the correct child member of Wrapper. You could also just represent the return values as a string if you wanted.

Note that using unions you need to be careful of the caveats: http://en.cppreference.com/w/cpp/language/union

EDIT 2: You could do this with a templated return

template<typename = T>
const T& getVal(const T& typeToAllowMethodOverriding) const;

Answer 2

Remember that 'virtual ...' means "make a function pointer in the class that I will use to call the correct derived class". It is just a pointer -- so you have to agree on the return type before you call it. C++ doesn't have the dynamic types and reflection of other languages - it has to know what the return type is before making the call.

Answer 3

You could make class my_interface a template class as well:

template<typename T>
class my_interface
{
public:
    virtual T getValue() const = 0;
};

This will generate an interface and a class for every type T that you use.

Answer 4

    template<typename U>
class my_interface
    {
    public:

        virtual  U  getValue() const = 0;
    };

    template<typename T>
    class my_class : public my_interface<T>
    {
    private:
        T    _value;
    public:
        my_class(T value) : _value(value) {} // initialize the attribute on construct

           T getValue() const { return  _value; }
    };

It works for all types but for string type you have to do specialization of templates

Answer 5

I think your best shot will be to use/implement something like boost::variant.

typedef boost::variant<char, short, int, float, double> Value;

class my_interface
{
public:
    virtual Value getValue() const = 0;
};

template<typename T>
class my_class : public my_interface
{
private:
    T    _value;
public:
    my_class(T value) : _value(value) {} // initialize the attribute on construct
    virtual Value getValue() const { return _value; }
};

Then you could implement the arithmetic operators:

Value operator+(const Value &lhs, const Value &rhs) {
    //Check the internal types of lhs and rhs and perform the operation
}

You can also wrap the boost::variant in another class, to provide conversion operators to the basic types.