Alternative pattern for virtual template

G

GeeRay

Hi all,
I have this problem: I need to implement a class hierarchy where the
main class has a template method that will be inherited by the subclass.
Something like:

class SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const = 0;
}


class SubClass: public SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const { cout << t << endl;}
}

Considering I know why it is not possible to make a template virtual, is
there an alternative pattern to solve this kind of problems.

Thanks in advance
 
N

Neelesh

Hi all,
        I have this problem: I need to implement a class hierarchy where the
main class has a template method that will be inherited by the subclass.
Something like:

class SuperClass
{
public:
        template<typename T>
        virtual void foo(const T& t) const = 0;

}

class SubClass: public SuperClass
{
public:
        template<typename T>
        virtual void foo(const T& t) const { cout << t << endl;}

}

Considering I know why it is not possible to make a template virtual, is
there an alternative pattern to solve this kind of problems.

Thanks in advance
Click to expand...

Making it a class template can solve the problem:

template<class T> class SuperClass
{
public:
virtual void foo(const T& t) const = 0;

};

template<class T> class SubClass: public SuperClass<T>
{
public:
virtual void foo(const T& t) const { cout << t << endl;}
//By the way, "virtual keyword isn't needed here

};

int main()
{
SuperClass<int> *s = new SubClass<int>();
s->foo(10); //prints 10

}
 
G

GeeRay

Neelesh ha scritto:
Hi all,
I have this problem: I need to implement a class hierarchy where the
main class has a template method that will be inherited by the subclass.
Something like:
[...cut...]
Thanks in advance
Click to expand...

Making it a class template can solve the problem:

template<class T> class SuperClass
{
public:
virtual void foo(const T& t) const = 0;

};

template<class T> class SubClass: public SuperClass<T>
{
public:
virtual void foo(const T& t) const { cout << t << endl;}
//By the way, "virtual keyword isn't needed here

};

int main()
{
SuperClass<int> *s = new SubClass<int>();
s->foo(10); //prints 10
Click to expand...


The problem is that I would like to use the same method with different
types:

SuperClass * s = new SubClass();
s->foo<int>(2);
s->foo<const char*> ("foo");
 
N

Noah Roberts

GeeRay said:
Hi all,
I have this problem: I need to implement a class hierarchy where the
main class has a template method that will be inherited by the subclass.
Something like:

class SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const = 0;
}


class SubClass: public SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const { cout << t << endl;}
}

Considering I know why it is not possible to make a template virtual, is
there an alternative pattern to solve this kind of problems.
Click to expand...

No. There are some things you can do but none of them generate the
equivalent of virtual template functions. Simple fact is that the
language doesn't support such a construct. How could it?

I find that any time I'm tempted to do this, my design is not exactly
correct.

The closest you might come is to use NVPI and account for every possible
argument to your template by hand:

struct Base
{
// Document the concept:
// T must be int or double.
template < typename T >
void f(T const& x);

protected:
virtual void do_f(double const& x) { ... }
virtual void do_f(int const& x) { ... }
};

template < >
void Base::f<double>(double const& x) { do_f(x); }
template < >
void Base::f<int>(int const& x) { do_f(x); }

Basically you're doing what the compiler would have to magically do if
it were to attempt supporting virtual template functions. As you can
see, pretty much impossible without full and future knowledge of all
calls to f<>(), which is why it isn't done.

I'm sure you could make some preprocessor stuff to construct much of the
above code, but you're still going to have to account for all possible
types passed to your function.

I'd suggest looking at alternative approaches.
 
M

Martin Eisenberg

GeeRay said:
class SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const = 0;
}

class SubClass: public SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const { cout << t << endl;}
}

Considering I know why it is not possible to make a template
virtual, is there an alternative pattern to solve this kind of
problems.
Click to expand...

If your higher-level goal is to ensure that the class does indeed
have a certain function, perhaps you can equip its clients with Boost
Concept Check.


Martin
 
M

Michael Doubez

No. There are some things you can do but none of them generate the
equivalent of virtual template functions. Simple fact is that the
language doesn't support such a construct. How could it?

I find that any time I'm tempted to do this, my design is not exactly
correct.

The closest you might come is to use NVPI and account for every possible
argument to your template by hand:

struct Base
{
// Document the concept:
// T must be int or double.
template < typename T >
void f(T const& x);

protected:
virtual void do_f(double const& x) { ... }
virtual void do_f(int const& x) { ... }

};

template < >
void Base::f<double>(double const& x) { do_f(x); }
template < >
void Base::f<int>(int const& x) { do_f(x); }

Basically you're doing what the compiler would have to magically do if
it were to attempt supporting virtual template functions. As you can
see, pretty much impossible without full and future knowledge of all
calls to f<>(), which is why it isn't done.

I'm sure you could make some preprocessor stuff to construct much of the
above code, but you're still going to have to account for all possible
types passed to your function.

I'd suggest looking at alternative approaches.
Click to expand...

On of this approach is to use dynamic polymorphism, that is if you can
define a same contract on your type. As an example if your foo is only
displaying a message with the data in parameter, your contract if that
the type should support (ostream<<T), you define the interface:

struct foo_ostreamable
{
virtual ostream& output(ostream&)const=0;
};

Then you define a templated foo_streambable implementation:

template<typename T>
struct foo_ostreamable_imp: foo_ostreamable
{
T value;
foo_ostreamable_imp(const T& t):value(t){}

virtual ostream& output(ostream& os)const{return os<<value;}
};

And finally the parameter of SuperClass::foo with templated
constructor:

struct foo_param
{
template<typename T>
foo_param(const T& t){data.reset(new foo_ostreamable_imp<T>(t));

scoped_ptr<foo_ostreamable> data;
};

// foo_param can be written into ostream
ostream& operator<<(ostream& os,const foo_param& p)
{
return p.data->output(os);
}

And finally, you define your classes:
class SuperClass
{
public:
virtual void foo(const foo_param&) const = 0;
};

class SubClass: public SuperClass
{
public:
virtual void foo(const foo_param& p) const { cout << p <<
endl;}
} ;

The compiler will automatically resolve with correct subtype:
SubClass s;
s.foo(1);
s.foo(0.1);
s.foo("bar");
....

If you want to keep/compare foo_param values, there is some management
to do such as deep copy and others to put it into canonical form. If a
type doesn't react as you want, you overload foo_param constructor.

There is an overhead but that depends on what you want.
 
G

GeeRay

Michael Doubez ha scritto:
GeeRay said:
Hi all,
I have this problem: I need to implement a class hierarchy where the
main class has a template method that will be inherited by the subclass.
Something like:
[cut]
Click to expand...
Click to expand...

On of this approach is to use dynamic polymorphism, that is if you can
define a same contract on your type. As an example if your foo is only
displaying a message with the data in parameter, your contract if that
the type should support (ostream<<T), you define the interface:

struct foo_ostreamable
{
virtual ostream& output(ostream&)const=0;
};

Then you define a templated foo_streambable implementation:

template<typename T>
struct foo_ostreamable_imp: foo_ostreamable
{
T value;
foo_ostreamable_imp(const T& t):value(t){}

virtual ostream& output(ostream& os)const{return os<<value;}
};

And finally the parameter of SuperClass::foo with templated
constructor:

struct foo_param
{
template<typename T>
foo_param(const T& t){data.reset(new foo_ostreamable_imp<T>(t));

scoped_ptr<foo_ostreamable> data;
};

// foo_param can be written into ostream
ostream& operator<<(ostream& os,const foo_param& p)
{
return p.data->output(os);
}

And finally, you define your classes:
class SuperClass
{
public:
virtual void foo(const foo_param&) const = 0;
};

class SubClass: public SuperClass
{
public:
virtual void foo(const foo_param& p) const { cout << p <<
endl;}
} ;

The compiler will automatically resolve with correct subtype:
SubClass s;
s.foo(1);
s.foo(0.1);
s.foo("bar");
...

If you want to keep/compare foo_param values, there is some management
to do such as deep copy and others to put it into canonical form. If a
type doesn't react as you want, you overload foo_param constructor.

There is an overhead but that depends on what you want.
Click to expand...

You're great!
Thank you very much, that's exactly what I was looking for.

-GR
 
D

DerTopper

Michael Doubez schrieb:
[snipped original problem about the problem of combining virtual
methods with templates]
On of this approach is to use dynamic polymorphism, that is if you can
define a same contract on your type. As an example if your foo is only
displaying a message with the data in parameter, your contract if that
the type should support (ostream<<T), you define the interface:

struct foo_ostreamable
{
virtual ostream& output(ostream&)const=0;
};

Then you define a templated foo_streambable implementation:

template<typename T>
struct foo_ostreamable_imp: foo_ostreamable
{
T value;
foo_ostreamable_imp(const T& t):value(t){}

virtual ostream& output(ostream& os)const{return os<<value;}
};

And finally the parameter of SuperClass::foo with templated
constructor:

struct foo_param
{
template<typename T>
foo_param(const T& t){data.reset(new foo_ostreamable_imp<T>(t));

scoped_ptr<foo_ostreamable> data;
};

// foo_param can be written into ostream
ostream& operator<<(ostream& os,const foo_param& p)
{
return p.data->output(os);
}

And finally, you define your classes:
class SuperClass
{
public:
virtual void foo(const foo_param&) const = 0;
};

class SubClass: public SuperClass
{
public:
virtual void foo(const foo_param& p) const { cout << p <<
endl;}
} ;

The compiler will automatically resolve with correct subtype:
SubClass s;
s.foo(1);
s.foo(0.1);
s.foo("bar");
...

If you want to keep/compare foo_param values, there is some management
to do such as deep copy and others to put it into canonical form. If a
type doesn't react as you want, you overload foo_param constructor.

There is an overhead but that depends on what you want.
Click to expand...

That's a good explanation. Is this pattern named already?

Stuart
 
M

Michael Doubez

Michael Doubez schrieb:
[snipped original problem about the problem of combining virtual
methods with templates]


On of this approach is to use dynamic polymorphism, that is if you can
define a same contract on your type. As an example if your foo is only
displaying a message with the data in parameter, your contract if that
the type should support (ostream<<T), you define the interface:
Click to expand...
struct foo_ostreamable
{
virtual ostream& output(ostream&)const=0;
};
Click to expand...
Then you define a templated foo_streambable implementation:
Click to expand...
template<typename T>
struct foo_ostreamable_imp: foo_ostreamable
{
T value;
foo_ostreamable_imp(const T& t):value(t){}
Click to expand...
virtual ostream& output(ostream& os)const{return os<<value;}
};
Click to expand...
And finally the parameter of SuperClass::foo with templated
constructor:
Click to expand...
struct foo_param
{
template<typename T>
foo_param(const T& t){data.reset(new foo_ostreamable_imp<T>(t));
Click to expand...
scoped_ptr<foo_ostreamable> data;
};
Click to expand...
// foo_param can be written into ostream
ostream& operator<<(ostream& os,const foo_param& p)
{
return p.data->output(os);
}
Click to expand...
And finally, you define your classes:
class SuperClass
{
public:
virtual void foo(const foo_param&) const = 0;
};
Click to expand...
class SubClass: public SuperClass
{
public:
virtual void foo(const foo_param& p) const { cout << p <<
endl;}
} ;
Click to expand...
The compiler will automatically resolve with correct subtype:
SubClass s;
s.foo(1);
s.foo(0.1);
s.foo("bar");
...
Click to expand...
If you want to keep/compare foo_param values, there is some management
to do such as deep copy and others to put it into canonical form. If a
type doesn't react as you want, you overload foo_param constructor.
Click to expand...
There is an overhead but that depends on what you want.
Click to expand...

That's a good explanation. Is this pattern named already?
Click to expand...

I think it is type erasure. It can be useful if you want virtual
member function that takes any iterator of a given kind (let say an
output iterator, it is easier to implement:) ) but are not too focused
on performances (an indirection plus a virtual call per call, an
allocation per copy , dynamic cast for comparison ...).

The idea is taken from an article in Overload published by ACCU:
http://accu.org/index.php/overloadonline

I don't remember which issue (around end of year 2007 IIRC)
 
D

DerTopper

Michael said:
The idea is taken from an article in Overload published by ACCU:
http://accu.org/index.php/overloadonline

I don't remember which issue (around end of year 2007 IIRC)
Click to expand...

Thanks again. Never heard of ACCU (I tried to look up what ACCU means,
but their homepage doesn't say anything about this acronym).

It seems that today is full of surprises (always a new thing to learn
out there). Unfortunately, I can't access any articles on this page
(it looks a bit amateurishly to me).

Stuart
 
M

Michael Doubez

Thanks again. Never heard of ACCU (I tried to look up what ACCU means,
but their homepage doesn't say anything about this acronym).
Click to expand...

ACCU = Association of C and C++ Users

But it is no longer C and C++ focused.
It seems that today is full of surprises (always a new thing to learn
out there). Unfortunately, I can't access any articles on this page
Click to expand...

Click on: "Go to the Overload Online archive"
Issues are in PDF. somme of them are accessible in HTML format.
 
D

DerTopper

Michael said:
ACCU = Association of C and C++ Users

But it is no longer C and C++ focused.

Click on: "Go to the Overload Online archive"
Issues are in PDF. somme of them are accessible in HTML format.
Click to expand...

Gosh, I didn't see the forest for all the trees.

Thanks again,

Stuart
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

C++ Template Virtual Function 6
Template argument deduction 3
alternative for virtual template function? 4
A mess with inheritance, virtual classes , and templates. 2
template pattern question 3
Error :: specialization of Template Function on Meta - Template Class 1
Template Class 4
Whether to choose an overload of template function or a partialspecialization of a functor(function 0

Members online

Total: 36 (members: 2, guests: 34)
Robots: 435

Forum statistics

Threads
473,769
Messages
2,569,580
Members
45,055
Latest member
SlimSparkKetoACVReview

Latest Threads

Top