Return value of virtual functions in interface - c++

Question

One class returns 'int', other returns 'double'. What is the signature of method 'GiveMeTheValue' in the interface of both classes.
I want to compile following code:
class Interface
{
public:
virtual arbitrary_type GimeMeTheValue(void) {};
};
class TakeInt : public Interface
{
public:
arbitrary_type GimeMeTheValue(void) {
return 10;
}
};
class TakeDouble : public Interface
{
public:
arbitrary_type GimeMeTheValue(void) {
return 3.14;
}
};
int main()
{
Interface * obj;
obj = new TakeInt();
cout << obj -> GimeMeTheValue() << endl; // It's 10, thank you
obj = new TakeDouble();
cout << obj -> GimeMeTheValue() << endl; // Oh it's 3.14, I love you c++
}
Of course there is no such an "arbitary_type".
This works ...
class Interface
{
public:
virtual void * GimeMeTheValue(void) {};
};
class TakeInt : public Interface
{
public:
void * GimeMeTheValue(void) {
int value = 10;
int * ptr = &value;
return ptr;
}
};
class TakeDouble : public Interface
{
public:
void * GimeMeTheValue(void) {
double value = 3.14;
double * ptr = &value;
return ptr;
}
};
int main()
{
Interface * obj;
obj = new TakeInt();
cout << *( (int *) (obj -> GimeMeTheValue()) ) << endl;
obj = new TakeDouble();
cout << *( (double *) (obj -> GimeMeTheValue()) ) << endl;
}
It is rather complicated to deal with "void *". Are there any other ideas to implement something simple (like in the first code example)? Thank you.

Answer 1

There is no way the base class Interface could know what distinct data type each descendant wants to return. Using different return types defeats the purpose of polymorphism. So the only way I can think to do this is to have GiveMeTheValue() return an object type that knows what kind of value it holds, and then make that object streamable.
enum VariantType {varNull, varInt, varDouble};
struct Variant
{
VariantType Type;
union {
int intValue;
double dblValue;
};
Variant() : Type(varNull) {}
Variant(int value) : Type(varInt), intValue(value) {}
Variant(double value) : Type(varDouble), dblValue(value) {}
void writeTo(std::ostream &strm)
{
switch (Type)
{
case varNull: strm << "(null)"; break;
case varInt: strm << intValue; break;
case varDouble: strm << dblValue; break;
}
}
};
class Interface
{
public:
virtual ~Interface() {}
virtual Variant GimeMeTheValue(void) = 0;
};
class TakeInt : public Interface
{
public:
Variant GimeMeTheValue(void)
{
return Variant(10);
}
};
class TakeDouble : public Interface
{
public:
Variant GimeMeTheValue(void)
{
return Variant(3.14);
}
};
std::ostream& operator<<(std::ostream &strm, const Variant &v)
{
v.writeTo(strm);
return strm;
}
int main()
{
Interface * obj;
obj = new TakeInt();
cout << obj->GimeMeTheValue() << endl; // It's 10, thank you
delete obj;
obj = new TakeDouble();
cout << obj->GimeMeTheValue() << endl; // Oh it's 3.14, I love you c++
delete obj;
}