C++ Make a generic interface - c++

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.