Template classes and abstraction of type

[Raistlin]

I have a template class with a lot methods for 3D operations, to be able to perform the operations on different types T(for the moment only unsigned char and unsigned short). I would like to set the type of the 3D array of a certain type T, be able to perform a lot of operations on this data regardless of the type and retrieve the type when I need type-related data from it (for example a slice of the volume).

Currently I create a class with pointers to instantiations of the classes with all possible data types, a selector to determine the current type, and I add a method for each underlying method of the template class, which calls the right version. This seems quite cumbersome, and needs a change of the wrapper implementation each time the template class is changed.

Is there a way to do something like the following :

template<class T>
class A
{
public:
		void doSomething();
		void doSomethingToo();
private:
		T** data;
		//...
};
 
class AWrapper
{
public:
		//Do not explicitly add methods
		T* operator->();//Return right pointer based on typeSelector_;
private:
		int typeSelector_;
		A<char>* charData_;
		A<short>* shortData_;		
};

template<class T>
class A
{
public:
		void doSomething();
		void doSomethingToo();
private:
		T** data;
		//...
};

class AWrapper
{
public:
		//Do not explicitly add methods
		T* operator->();//Return right pointer based on typeSelector_;
private:
		int typeSelector_;
		A<char>* charData_;
		A<short>* shortData_;		
};

To copy to clipboard, switch view to plain text mode 

Off course this does not work since T is still undefined in the wrapper. Any way to accomplish this?

[wysota]

How about using dynamic_cast?

[Raistlin]

I don't really see how to use a dynamic_cast in this construction. The key seems to be overloading the dereferencing operator, but here I always need to return a type. And that type is not known in advance in my case.

[wysota]

Could you try to describe with more details what you are trying to do? What you wrote earlier seems unclear to me. What is the cast operator for? How would you like to use it and in what situation?

[Raistlin]

Well, I have a 3D volume class which looks like this:

template<class T>
class Array2D;
 
template<class T>
class Array3D;
 
template<class T>
class Volume
{
public:
	//All these methods operate on data3D_ and calling them should not require knowledge of the datatype
	//A lot of methods are of this type !
	void loadVolume();
	void exportVolume();
 
	void performSomeOtherOperation();
 
	//These operations ARE type specific
	//Only a small number of methods are of this type
	T* extractSlice(int zPosition);
	void setSliceAt(int zPosition, Array2D<T>& slice);
 
 
private :
	//Type can be U8 or U16 based on file format when loading data
	Array3D<T>* data3D_;
};

template<class T>
class Array2D;

template<class T>
class Array3D;

template<class T>
class Volume
{
public:
	//All these methods operate on data3D_ and calling them should not require knowledge of the datatype
	//A lot of methods are of this type !
	void loadVolume();
	void exportVolume();

	void performSomeOtherOperation();

	//These operations ARE type specific
	//Only a small number of methods are of this type
	T* extractSlice(int zPosition);
	void setSliceAt(int zPosition, Array2D<T>& slice);


private :
	//Type can be U8 or U16 based on file format when loading data
	Array3D<T>* data3D_;
};

To copy to clipboard, switch view to plain text mode 

I then need a second class which should do the following:

//No template !!
class VolumeWrapper
{
public:
	//All methods not requiring knowledge of the datatype should not be redefined
	//This can not compile because only type of return value differs
	Volume<char>* operator->() {if (charType_) return data3DChar_; else //Do nothing? This should never occur because if type short, first version should be called}
	Volume<short>* operator->() {if (!charType_) return data3DShort_;} else //Do nothing? This should never occur because if type short, second version should be called}
 
	//These operations ARE type specific
	//User should first retrieve data type based on charType_ and use right version
 
	//These can not compile because only type of return value differs
	Array2D<char>* extractSlice(int zPosition);
	Array2D<short>* extractSlice(int zPosition);
 
	void setSliceAt(int zPosition, Array2D<char>& slice);	
	void setSliceAt(int zPosition, Array2D<short>& slice);
 
 
private :
	//Type can be U8 or U16 based on file format
	Volume<char>* data3DChar_;
	Volume<short>* data3DShort_;
	bool charType_;
};

//No template !!
class VolumeWrapper
{
public:
	//All methods not requiring knowledge of the datatype should not be redefined
	//This can not compile because only type of return value differs
	Volume<char>* operator->() {if (charType_) return data3DChar_; else //Do nothing? This should never occur because if type short, first version should be called}
	Volume<short>* operator->() {if (!charType_) return data3DShort_;} else //Do nothing? This should never occur because if type short, second version should be called}

	//These operations ARE type specific
	//User should first retrieve data type based on charType_ and use right version

	//These can not compile because only type of return value differs
	Array2D<char>* extractSlice(int zPosition);
	Array2D<short>* extractSlice(int zPosition);

	void setSliceAt(int zPosition, Array2D<char>& slice);	
	void setSliceAt(int zPosition, Array2D<short>& slice);


private :
	//Type can be U8 or U16 based on file format
	Volume<char>* data3DChar_;
	Volume<short>* data3DShort_;
	bool charType_;
};

To copy to clipboard, switch view to plain text mode 

[jacek]

When is the _charType value determined?

[wysota]

Can't you have a common base class for all Volume types and return the base class pointer and later on use casting to determine which real class it is?

[Raistlin]

@jacek

The type can already be determined in the constructor of VolumeWrapper. Normally it would be done when calling loadVolume, and the type would be determined based on the type of image files which are loaded (U8 or U16). But it is not so difficult to poll a file's type before creating the object. But nevertheless, from then on a lot of methods are used where the type should not be specified.

@wysota

Do you mean something like this:

/*Pure abstract class, only has type specified and lists all methods operating on the 
  volume data, but not requiring explicit exposure of type.*/
 
class VolumeGeneral
{
public:
	enum type
	{
		typeUnknown,
		typeU8,
		typeU16
	};
 
	VolumeGeneral(void);
	~VolumeGeneral(void);
 
	type getType() const;
 
	virtual void init() = 0;
	virtual void doSomething() = 0;
 
protected:
	type type_;
};
 
VolumeGeneral::VolumeGeneral(void)
{
	type_ = typeUnknown;
}
 
VolumeGeneral::~VolumeGeneral(void)
{
}
 
VolumeGeneral::type VolumeGeneral::getType() const
{
	return type_ ;
}

/*Pure abstract class, only has type specified and lists all methods operating on the 
  volume data, but not requiring explicit exposure of type.*/

class VolumeGeneral
{
public:
	enum type
	{
		typeUnknown,
		typeU8,
		typeU16
	};

	VolumeGeneral(void);
	~VolumeGeneral(void);

	type getType() const;

	virtual void init() = 0;
	virtual void doSomething() = 0;

protected:
	type type_;
};

VolumeGeneral::VolumeGeneral(void)
{
	type_ = typeUnknown;
}

VolumeGeneral::~VolumeGeneral(void)
{
}

VolumeGeneral::type VolumeGeneral::getType() const
{
	return type_ ;
}

To copy to clipboard, switch view to plain text mode 

/*Class containing all actual code. Methods operating on data are overridden to actually 
  do something. Type-specific methods are added to allow an extra interface for these 
  operations.*/
 
template <class T>
class VolumeSpecified : public VolumeGeneral
{
public:
	VolumeSpecified(void);
	~VolumeSpecified(void);
 
	void init();
	void doSomething();
 
	void setData(T& data);
	T getData() const;
 
private:
	T data_;
};
 
template <class T>
VolumeSpecified<T>::VolumeSpecified(void)
{
	if (typeid(T) == typeid(unsigned char))
		type_ = typeU8;
 
	else if (typeid(T) == typeid(unsigned short))
		type_ = typeU16;
 
	//else keep typeUnknown (already set)
}
 
template <class T>
VolumeSpecified<T>::~VolumeSpecified(void)
{
}
 
template <class T>
void VolumeSpecified<T>::setData(T& data)
{
	data_ = data;
}
 
template <class T>
T VolumeSpecified<T>::getData() const
{
	return data;
}

/*Class containing all actual code. Methods operating on data are overridden to actually 
  do something. Type-specific methods are added to allow an extra interface for these 
  operations.*/

template <class T>
class VolumeSpecified : public VolumeGeneral
{
public:
	VolumeSpecified(void);
	~VolumeSpecified(void);

	void init();
	void doSomething();

	void setData(T& data);
	T getData() const;

private:
	T data_;
};

template <class T>
VolumeSpecified<T>::VolumeSpecified(void)
{
	if (typeid(T) == typeid(unsigned char))
		type_ = typeU8;

	else if (typeid(T) == typeid(unsigned short))
		type_ = typeU16;

	//else keep typeUnknown (already set)
}

template <class T>
VolumeSpecified<T>::~VolumeSpecified(void)
{
}

template <class T>
void VolumeSpecified<T>::setData(T& data)
{
	data_ = data;
}

template <class T>
T VolumeSpecified<T>::getData() const
{
	return data;
}

To copy to clipboard, switch view to plain text mode 

/*Use of the classes in the main program*/
 
//Check for type of files and allocate based on type
VolumeGeneral* volume = new VolumeSpecified<unsigned short>();
 
//Perform type specific operations
if (volume->getType() == VolumeGeneral::typeU16)
{
	VolumeSpecified<unsigned short>* volumeS = dynamic_cast<VolumeSpecified<unsigned short>*>(volume);
	volumeS->setData(365);
}
 
//Perform general operations
volume->init();
volume->doSomething();
 
delete volume;

/*Use of the classes in the main program*/

//Check for type of files and allocate based on type
VolumeGeneral* volume = new VolumeSpecified<unsigned short>();

//Perform type specific operations
if (volume->getType() == VolumeGeneral::typeU16)
{
	VolumeSpecified<unsigned short>* volumeS = dynamic_cast<VolumeSpecified<unsigned short>*>(volume);
	volumeS->setData(365);
}

//Perform general operations
volume->init();
volume->doSomething();

delete volume;

To copy to clipboard, switch view to plain text mode 

[Michiel]

Sorry, but I'm having difficulty understanding why you need wrappers of any kind. All your wrapper seems to be doing is introduce an unnecessary syntax (wrapperNotPointer->volumeFunction).

If you ask me, you only need your Volume class. Without any changes (except I'm fuzzy on the return type of extractSlice).

template <class T>
class Volume {
    public:
 
        void loadVolume();
 
        void exportVolume();
 
        void performSomeOtherOperation();
 
        Array2D<T>* extractSlice(int zPosition);
 
        void setSliceAt(int zPosition, Array2D<T>& slice);   
 
    private:
 
        Array3D<T>* data3D_;
};

template <class T>
class Volume {
    public:
        
        void loadVolume();

        void exportVolume();
        
        void performSomeOtherOperation();
        
        Array2D<T>* extractSlice(int zPosition);
        
        void setSliceAt(int zPosition, Array2D<T>& slice);   
    
    private:
        
        Array3D<T>* data3D_;
};

To copy to clipboard, switch view to plain text mode 

[wysota]

@wysota

Do you mean something like this:

Yes and no. I don't see a need for any wrapper here. Returning the base class pointer and using dynamic_cast should be sufficient to determine everything you need. Unless of course you have some wicked usecase in mind which you are not telling us about.

[Raistlin]

I modified the example a bit to make it a bit more clear. I use a single value to type T here for simplicity, but of course this not what happens in reality. But it is just to illustrate the idea.

/*Use of the classes in the main program*/
 
//Check for type of files and allocate based on type
VolumeGeneral::type imageType;
 
//Determine the type based on input files
...
 
//Allocate with righ type 
VolumeGeneral* volume = 0;
 
if (imageType == typeU16)
	volume = new VolumeSpecified<unsigned short>();
 
else if (imageType == typeU8)
	volume = new VolumeSpecified<unsigned char>();
 
else
	break;
 
//Perform general operations
volume->init();
volume->doSomething();
 
//Perform type specific operations
if (volume->getType() == VolumeGeneral::typeU16)
{
	VolumeSpecified<unsigned short>* volumeS = dynamic_cast<VolumeSpecified<unsigned short>*>(volume);
	unsigned short testVariable = volumeS->getData();
}
 
delete volume;

/*Use of the classes in the main program*/

//Check for type of files and allocate based on type
VolumeGeneral::type imageType;

//Determine the type based on input files
...

//Allocate with righ type 
VolumeGeneral* volume = 0;

if (imageType == typeU16)
	volume = new VolumeSpecified<unsigned short>();

else if (imageType == typeU8)
	volume = new VolumeSpecified<unsigned char>();

else
	break;

//Perform general operations
volume->init();
volume->doSomething();

//Perform type specific operations
if (volume->getType() == VolumeGeneral::typeU16)
{
	VolumeSpecified<unsigned short>* volumeS = dynamic_cast<VolumeSpecified<unsigned short>*>(volume);
	unsigned short testVariable = volumeS->getData();
}

delete volume;

To copy to clipboard, switch view to plain text mode 

I don't see how I can do this without the extra class. If I only have my template class, I always need to specify the type, right? I can not use an object of type template class T without specifying T. So I need a base class which does not have any type to provide an interface.

What do you mean by using a 'base class pointer' when you say I don't need a wrapper? It seems like I need to list all methods in my abstract base class, since I need it as interface for my methods. If you talk about casting some base class pointer to the right template type, it seems this is something I always need to do, regardless whether I am exporting or importing data, or I am doing something where the type does not need to be visible.

Maybe I just need some example code on how to apply what you mean in my case, since it seems I am missing out on something ...

[wysota]

class Image {
public:
  virtual void init() = 0;
  virtual void doSomething() = 0;
  virtual ~Image(){}
};
 
class Image16 : public Image {
public:
  Image16(unsigned short *data){
    //...
  }
  void init(){ ... }
  void doSomething(){ ... }
};
 
class Image8 : public Image {
 //...
};
 
Image *img;
if(type==16)
  img = new Image16(data);
else img = new Image8(data);
img->init();
img->doSomething();

class Image {
public:
  virtual void init() = 0;
  virtual void doSomething() = 0;
  virtual ~Image(){}
};

class Image16 : public Image {
public:
  Image16(unsigned short *data){
    //...
  }
  void init(){ ... }
  void doSomething(){ ... }
};

class Image8 : public Image {
 //...
};

Image *img;
if(type==16)
  img = new Image16(data);
else img = new Image8(data);
img->init();
img->doSomething();

To copy to clipboard, switch view to plain text mode 

Isn't that what you want? You don't reference the actual class type anywhere apart from calling the constructor, so there is no problem of not knowing the type.

[Raistlin]

Thank you for that code wysota. However, it seems like I am basically doing the same thing. The only difference I see is that your solution has less code because you do not keep track of the type in your base class. However, I sometimes do need to do some type-specific operations (like in the example) to interface with the main program, so I have to keep track of it to get out the right type of data.

In conclusion, this is already a lot cleaner than what I started from. The only thing I need to do is to add all non-type specific methods as pure virtual methods to the base class.

[wysota]

However, I sometimes do need to do some type-specific operations (like in the example) to interface with the main program, so I have to keep track of it to get out the right type of data.

if((Image16 *image16 = dynamic_cast<Image16*>(img))!=0){
  image16->specificMethod16();
} else if((Image8 *image8 = dynamic_cast<Image8*>(img))!=0){
  image8->specificMethod8();
} else {
  std::cerr << "Unknown Image subclass encountered" << std::endl;
}

if((Image16 *image16 = dynamic_cast<Image16*>(img))!=0){
  image16->specificMethod16();
} else if((Image8 *image8 = dynamic_cast<Image8*>(img))!=0){
  image8->specificMethod8();
} else {
  std::cerr << "Unknown Image subclass encountered" << std::endl;
}

To copy to clipboard, switch view to plain text mode 

[Raistlin]

Oh, thanks for that addition. I did not know casting to the wrong type returned 0 instead of a junk value.

[wysota]

That's the idea of dynamic_cast. If your Image class inherited QObject, you could also use qobject_cast.