'if' with templates in C++ - c++

Question

I need to do something like this:
template <typename Matrix_xx>
bool ProcessMatrix<Matrix_xx>::function1(Matrix_xx a) {
int x, y;
// ... some code here ... //
if (Matrix_xx == Matrix_1D) {
a->readFromFile(x);
} else if (Matrix_xx == Matrix_2D) {
a->readFromFile(x, y);
} // ...
}
i.e., to call different functions depends on the template argument. The code above wouldn't compile because there are only Matrix_1D::readFromFile(int x) and Matrix_2D::readFromFile(int x, int y). I don't want to split function1 into two different functions only because there would be a lot of doubled code. Is there another way?

Answer 1

Wrap the type-specific code in either overloaded function or explicitly specialized template:
void doReadFromFile(Matrix_1D &a, int x, int y)
{
a->readFromFile(x);
}
void doReadFromFile(Matrix_2D &a, int x, int y)
{
a->readFromFile(x, y);
}
template <typename Matrix_xx>
bool ProcessMatrix<Matrix_xx>::function1(Matrix_xx a) {
int x, y;
// ... some code here ... //
doReadFromFile(a, x, y);
}
If Matrix_xx is Matrix_1D, overloading will select the first overload, if it is Matrix_2D, overloading will select the second overload and if it's anything else, it won't compile. But if somebody provides new type of matrix, they can make it compile by defining the doReadFromFile for it.
This is generally useful trick and reason why standard library uses "traits"—they can be defined for class somebody gives you and they can be defined for non-class types. The "traits" can be either in the form of explicitly specialized templates or free functions, usually looked up with argument-dependent lookup (placed in the namespace of their argument, not the template).
For completeness, the explicit specialization would look like:
template <typename Matrix_xx>
struct doReadFromFile {};
template <>
struct<Matrix_1D> struct doReadFromFile {
void operator()(Matrix_1D &a, int x, int y) {
a->readFromFile(x);
}
}
template <>
struct<Matrix_1D> struct doReadFromFile {
void operator()(Matrix_1D &a, int x, int y) {
a->readFromFile(x, y);
}
}

Answer 2

Couldn't you make the argument to readFromFile a reference to a vector and let the Matrix_xx instance decide how many indices to fill in? That would eliminate the need for a conditional check.

Answer 3

You can get around that using the typeid operator.
Using it, your code would become:
template <typename Matrix_xx>
bool ProcessMatrix<Matrix_xx>::function1(Matrix_xx a) {
int x, y;
// ... some code here ... //
if (typeid(Matrix_xx) == typeid(Matrix_1D)) {
a->readFromFile(x);
} else if (typeid(Matrix_xx) == typeid(Matrix_2D)) {
a->readFromFile(x, y);
} // ...
}
or you could do it with a switch:
switch(typeid(Matrix_xx))
{
case typeid(Matrix_1D):
a->readFromFile(x);
break;
case typeid(Matrix_2D):
a->readFromFile(x,y);
break;
// etc, etc
}
[EDIT:] For those that say it won't compile, I'd be most interested in knowing what the functional difference between the code I left above and the code below, which is taken from a working project:
pdfArray.h
#ifndef PDFARRAY_H
#define PDFARRAY_H
#include "pdfObj.h"
#include "pdfTypes.h"
class pdfArray : public pdfObj
{
public:
pdfArray();
pdfArray(const pdfArray &src);
size_t size()
{
return(mArray->size());
}
void clear();
~pdfArray();
template <typename T> void addItem(const T *newItem)
{
//cout << typeid(T).name() << endl;
pdfObj *item = new T(*newItem);
mArray->push_back(item);
}
pdfObj *getItem(unsigned int itemIndex);
const bstring& toString();
pdfArray &operator=(const pdfArray &src);
private:
vecObjPtr *mArray;
};
#endif // PDFARRAY_H
excerpt from pdfArray.cpp
pdfArray::pdfArray(const pdfArray &src)
{
vecObjPtrIter iter;
pdfObj *ptr;
mArray = new vecObjPtr;
for (iter=src.mArray->begin(); iter!=src.mArray->end(); iter++)
{
ptr = *iter;
if (typeid(*ptr) == typeid(pdfString))
addItem( (pdfString*)ptr );
if (typeid(*ptr) == typeid(pdfInt))
addItem( (pdfInt*)ptr );
if (typeid(*ptr) == typeid(pdfFloat))
addItem( (pdfFloat*)ptr );
if (typeid(*ptr) == typeid(pdfArray))
addItem( (pdfArray*)ptr );
}
}