By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
458,184 Members | 1,495 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 458,184 IT Pros & Developers. It's quick & easy.

alternative for virtual template function?

P: n/a
I have an abstract base class which contains a function that I would
like to template, but virtual template functions are illegal. I put a
mini code example below, which doesn't do anything great, but reflects
the structure of my problem.

In a nutshell, the abstr. base class VectorCreator has a function
createVector whose return type is unfortunately fixed to
vector<double>. Only now I discovered that some implementations would
like to work with other types, such as vector<int>. I could just
template the VectorCreator class, but the problem is that pointers to
VectorCreator are passed around in the whole project, so templating it
would require too many changes. It's okay to change the createVector
function, but not the whole VectorCreator class (by introducing a
class-scope template). Here is the example code:

#include <iostream>
#include <vector>

// ABC
class VectorCreator {
public:
virtual ~VectorCreator() {}
virtual std::vector<double>* createVector() = 0; // it's illegal to
template the function :(
};

// concrete implementation example
class VectorCreator1 : public VectorCreator {
typedef std::vector<doubleT;
public:
VectorCreator1() {}
~VectorCreator1() {}
T* createVector() {
T* type = new T();
type->push_back(10.2);
return type;
}
};

// like foo here, there are many fct's and classes that are called or
// initialized with VectorCreator*, so VectorCreator cannot be
// templated (would require changing hundreds of source files)
void foo(VectorCreator* sc){
std::vector<double>* myvector = sc->createVector();
std::cout << (*myvector)[0] << std::endl;
delete myvector;
}

int main(double argc, char** argv){
VectorCreator* sc = new VectorCreator1();
foo(sc);
delete sc;
return EXIT_SUCCESS;
}

I think I found an acceptable solution (see below), but I was
wondering if anyone has a better idea how to deal with this problem. I
heard that the Visitor pattern might help in situations where one
would like virtual templates, but I don't know how.
#include <iostream>
#include <vector>

// ABC
class VectorCreator {
public:
virtual ~VectorCreator() {}
virtual void createVector(std::vector<double>*&) = 0;
virtual void createVector(std::vector<int>*&) = 0;
};

// concrete class example
class DoubleVectorCreator : public VectorCreator {
public:
DoubleVectorCreator() {}
~DoubleVectorCreator() {}
void createVector(std::vector<double>*& x) {
x = new std::vector<double>();
x->push_back(10.2);
}
void createVector(std::vector<int>*& x) {
std::cerr << "unimplemented";
}
};

class IntVectorCreator : public VectorCreator {
public:
IntVectorCreator() {}
~IntVectorCreator() {}
void createVector(std::vector<int>*& x) {
x = new std::vector<int>();
x->push_back(10);
}
void createVector(std::vector<double>*& x) {
std::cerr << "unimplemented";
}
};

void foo(VectorCreator* sc){
// specialized behaviors
if(dynamic_cast<DoubleVectorCreator*>(sc)){
std::vector<double>* myvector;
sc->createVector(myvector);
std::cout << (*myvector)[0] << std::endl;
delete myvector;
}
else if(dynamic_cast<IntVectorCreator*>(sc)){
std::vector<int>* myvector;
sc->createVector(myvector);
std::cout << (*myvector)[0] << std::endl;
delete myvector;
}
}

int main(double argc, char** argv){
VectorCreator* sc = new DoubleVectorCreator();
foo(sc);
delete sc;

VectorCreator* sc2 = new IntVectorCreator();
foo(sc2);
delete sc2;

return EXIT_SUCCESS;
}

Thanks!
Markus

Jul 23 '08 #1
Share this Question
Share on Google+
3 Replies


P: n/a
I have an abstract base class which contains a function that I would
like to template, but virtual template functions are illegal. I put a
mini code example below, which doesn't do anything great, but reflects
the structure of my problem.

In a nutshell, the abstr. base class VectorCreator has a function
createVector whose return type is unfortunately fixed to
vector<double>. Only now I discovered that some implementations would
like to work with other types, such as vector<int>. I could just
template the VectorCreator class, but the problem is that pointers to
VectorCreator are passed around in the whole project, so templating it
would require too many changes. It's okay to change the createVector
function, but not the whole VectorCreator class (by introducing a
class-scope template).
I think you'd better template the class. The problem with old code can
be
circumventÅd by introducing a new class template and typdef-ing it:

template<typename T>
class VectorCreatorTempl {
public:
virtual ~VectorCreator() {}
virtual std::vector<T>* createVector() = 0;
};

typedef VectorCreatorTempl<doubleVectorCreator;
BTW: For factory functions it is generally preferred to return an
auto_ptr
instead of a raw pointer.
Jul 23 '08 #2

P: n/a
On 23 jul, 02:48, Markus Dehmann <markus.dehm...@gmail.comwrote:
I have an abstract base class which contains a function that I would
like to template, but virtual template functions are illegal. I put a
mini code example below, which doesn't do anything great, but reflects
the structure of my problem.

In a nutshell, the abstr. base class VectorCreator has a function
createVector whose return type is unfortunately fixed to
vector<double>. Only now I discovered that some implementations would
like to work with other types, such as vector<int>. I could just
template the VectorCreator class, but the problem is that pointers to
VectorCreator are passed around in the whole project, so templating it
would require too many changes. It's okay to change the createVector
function, but not the whole VectorCreator class (by introducing a
class-scope template). Here is the example code:

#include <iostream>
#include <vector>

// ABC
class VectorCreator {
public:
* virtual ~VectorCreator() {}
* virtual std::vector<double>* createVector() = 0; // it's illegal to
template the function :(

};

// concrete implementation example
class VectorCreator1 : public VectorCreator {
* typedef std::vector<doubleT;
public:
* VectorCreator1() {}
* ~VectorCreator1() {}
* T* createVector() {
* * T* type = new T();
* * type->push_back(10.2);
* * return type;
* }

};

// like foo here, there are many fct's and classes that are called or
// initialized with VectorCreator*, so VectorCreator cannot be
// templated (would require changing hundreds of source files)
void foo(VectorCreator* sc){
* std::vector<double>* myvector = sc->createVector();
* std::cout << (*myvector)[0] << std::endl;
* delete myvector;

}

int main(double argc, char** argv){
* VectorCreator* sc = new VectorCreator1();
* foo(sc);
* delete sc;
* return EXIT_SUCCESS;

}

I think I found an acceptable solution (see below), but I was
wondering if anyone has a better idea how to deal with this problem. I
heard that the Visitor pattern might help in situations where one
would like virtual templates, but I don't know how.

#include <iostream>
#include <vector>

// ABC
class VectorCreator {
public:
* virtual ~VectorCreator() {}
* virtual void createVector(std::vector<double>*&) = 0;
* virtual void createVector(std::vector<int>*&) = 0;

};

// concrete class example
class DoubleVectorCreator : public VectorCreator {
public:
* DoubleVectorCreator() {}
* ~DoubleVectorCreator() {}
* void createVector(std::vector<double>*& x) {
* * x = new std::vector<double>();
* * x->push_back(10.2);
* }
* void createVector(std::vector<int>*& x) {
* * std::cerr << "unimplemented";
* }

};

class IntVectorCreator : public VectorCreator {
public:
* IntVectorCreator() {}
* ~IntVectorCreator() {}
* void createVector(std::vector<int>*& x) {
* * x = new std::vector<int>();
* * x->push_back(10);
* }
* void createVector(std::vector<double>*& x) {
* * std::cerr << "unimplemented";
* }

};

void foo(VectorCreator* sc){
* // specialized behaviors
* if(dynamic_cast<DoubleVectorCreator*>(sc)){
* * std::vector<double>* myvector;
* * sc->createVector(myvector);
* * std::cout << (*myvector)[0] << std::endl;
* * delete myvector;
* }
* else if(dynamic_cast<IntVectorCreator*>(sc)){
* * std::vector<int>* myvector;
* * sc->createVector(myvector);
* * std::cout << (*myvector)[0] << std::endl;
* * delete myvector;
* }

}

int main(double argc, char** argv){
* VectorCreator* sc = new DoubleVectorCreator();
* foo(sc);
* delete sc;

* VectorCreator* sc2 = new IntVectorCreator();
* foo(sc2);
* delete sc2;

* return EXIT_SUCCESS;

}

I'd template the class or the function and refactor the code. If
you're going to start using dynamic_cast across all of your code, you
don't even need the createVector() function as a virtual in the base
class. Just dynamic cast to the appropriate pointer and call a
function such as createIntVector() or createDoubleVector() which you
can create in the derived classes.

--
Leandro T. C. Melo
Jul 24 '08 #3

P: n/a
Markus Dehmann wrote:
I have an abstract base class which contains a function that I would
like to template, but virtual template functions are illegal. I put a
mini code example below, which doesn't do anything great, but reflects
the structure of my problem.

In a nutshell, the abstr. base class VectorCreator has a function
createVector whose return type is unfortunately fixed to
vector<double>. Only now I discovered that some implementations would
like to work with other types, such as vector<int>. I could just
template the VectorCreator class, but the problem is that pointers to
VectorCreator are passed around in the whole project, so templating it
would require too many changes. It's okay to change the createVector
function, but not the whole VectorCreator class (by introducing a
class-scope template). Here is the example code:
<snip>
#include <iostream>
#include <vector>

// ABC
class VectorCreator {
public:
virtual ~VectorCreator() {}
virtual void createVector(std::vector<double>*&) = 0;
virtual void createVector(std::vector<int>*&) = 0;
};

// concrete class example
class DoubleVectorCreator : public VectorCreator {
public:
DoubleVectorCreator() {}
~DoubleVectorCreator() {}
void createVector(std::vector<double>*& x) {
x = new std::vector<double>();
x->push_back(10.2);
}
void createVector(std::vector<int>*& x) {
std::cerr << "unimplemented";
}
};

class IntVectorCreator : public VectorCreator {
public:
IntVectorCreator() {}
~IntVectorCreator() {}
void createVector(std::vector<int>*& x) {
x = new std::vector<int>();
x->push_back(10);
}
void createVector(std::vector<double>*& x) {
std::cerr << "unimplemented";
}
};

void foo(VectorCreator* sc){
// specialized behaviors
if(dynamic_cast<DoubleVectorCreator*>(sc)){
std::vector<double>* myvector;
sc->createVector(myvector);
std::cout << (*myvector)[0] << std::endl;
delete myvector;
}
else if(dynamic_cast<IntVectorCreator*>(sc)){
std::vector<int>* myvector;
sc->createVector(myvector);
std::cout << (*myvector)[0] << std::endl;
delete myvector;
}
}

int main(double argc, char** argv){
VectorCreator* sc = new DoubleVectorCreator();
foo(sc);
delete sc;

VectorCreator* sc2 = new IntVectorCreator();
foo(sc2);
delete sc2;

return EXIT_SUCCESS;
}
Notice that the foo() function is switching on type. This is a classic
anti-pattern, which is resolved by implementing foo() in the
VectorCreator class itself.

i.e.

void DoubleVectorCreator::foo()
void IntVectorCreator::foo()

(There are other ways of switching on type too, such as function
overloading and templates.)

The question is what you need to *do* with these vectors/factories, that
requires them to have the same base class? What's the common
functionality? If they are logically separate then the only moral thing
to do is to separate them in your code.

The 'std::cerr<<"unimplemented"' line is another OO anti-pattern. It's
normal for factories to create objects with a common base class (e.g.
my_vector):

std::auto_ptr<my_vectorIntVectorCreator::create()
std::auto_ptr<my_vectorDoubleVectorCreator::create ()

If you don't like dynamic memory allocation and virtual functions, then
try templates.

Hope that helps a little,

Calum
Jul 25 '08 #4

This discussion thread is closed

Replies have been disabled for this discussion.