Pure Virtual member function with compile-time known parameter? - c++

Question

I'm practicing Type Erasure Patterns by trying to implement one for STL containers and I'm stuck with on the pure virtual member functions of those containers. I do not know how to implement the "concept" of the type erasure pattern which acts as the interface, holding the pure virtual member functions shared by the erased types. Functions like Push will require a compile-time known parameter. As I understand, virtual functions cannot use auto or be templatized, so how can I go about writing the interface?
I tried using the keyword 'typename' to tell the compiler that the type will be given later, but it does not compile.
This is what I have so far for the 'concept' interface:
class Concept{
public:
virtual void push(typename T val) = 0;
virtual typename T pop() = 0;
};
The error received currently is as such:
error: expected nested-name-specifier before ‘T’ virtual void push(typename T val) = 0;
^
error: expected ‘,’ or ‘...’ before ‘val’ virtual void push(typename T val) = 0;
^~~
error: expected nested-name-specifier before ‘T’ virtual typename T pop() = 0;
If anyone can give me some advice regarding this, I'd really appreciate it. Thank you all in advance for your kind help and your time.

Answer 1

The typename keyword can only be part of a template declaration.
template <typename T> class Concept{
public:
virtual void push(T val) = 0;
virtual T pop() = 0;
};
You have mixed in your mind templates and pure virtual functions. The first is compile time, the second is run time.
Templates allow you to avoid duplicating code for different data types, where pure virtual member functions allow you to use different polymorphic interfaces that inherit from the same type. Type erasure has also nothing to do with virtual member functions. Two completely different things.
Once the above template is instantiated with, say, int, then it is equal to this:
class Concept{
public:
virtual void push(int val) = 0;
virtual int pop() = 0;
};
Now this class is abstract; you cannot instantiate it, but you can inherit:
class f1 : public Concept {
public:
virtual void push(int val) { ... define it }
virtual int pop() { ... define it}
};
class f2 : public Concept {
public:
virtual void push(int val) { ... define it }
virtual int pop() { ... define it}
... more members
};
And use it polymorphically:
Concept* a = new f1();
Concept* b = new f2();
// dynamic_cast<f1>(a) will return a f1*
// dynamic_cast<f2>(b) will return a f2*

Answer 2

I don't think you really want to have an interface with an indefinite number of the push and pop methods with different arguments. I also don't think you want to have a number of different implementations of the Concept descendants and a separate stack for each type.
It seems you want to push to the stack objects of different types and then pop them. In this case, it could be something like this:
struct Container
{
template<typename T>
Container(T t);
template<typename U>
U cast();
};
class Stack
{
public:
virtual void push(Container val) = 0;
virtual Container pop() = 0;
};
class ConcreteStack : public Stack
{
public:
void push(Container val);
Container pop();
};
int main()
{
ConcreteStack stack;
stack.push(25);
stack.push(std::string("abcd"));
std::string str = stack.pop().cast<std::string>();
int num = stack.pop().cast<int>();
}
Unfortunetly, I don't see the way to escape explicit type casting when pop. There couldn't be few methods with the same name that differ only in returning types.