具有模板的C ++调用函数具有继承性

Question

So I have a class that defines a TileGrid:

template<typename T>
class TileGrid { ... };

I fill in the template with a class called ImageTile

class ImageTile { ... };

I have a child class of ImageTile that I have defined that looks like this:

class FFTWImageTile : public ImageTile { ... };

In a separate file I define the following function:

void writeDataToFile(TileGrid<ImageStitching::ImageTile> * grid, std::string fileName);

(note: both ImageTile and FFTWImageTile are in the ImageStitching namespace)

Now all of the above compiles just fine, but when I try to use it I get an error.

Here is an example test case that is using it:

namespace is = ImageStitching;
TileGrid<is::FFTWImageTile> * grid = new TileGrid<is::FFTWImageTile> ( ... );
writeTranslationsToFile(grid, "output.txt");

When compiling the test case I get the following error:

error: cannot convert 'TileGrid<ImageStitching::FFTWImageTile>*' to 'TileGrid<ImageStitching::ImageTile>*' for argument '1' to 'void writeTranslationsToFile(TileGrid<ImageStitching::ImageTile>*, std::string)'

Anyway I can make this happen in C++?? I've looked all over and cant seem to find some help with making a function that has a parameter featuring a template that has child/parent relationships.

Edit:

Everyone's answers have been exceptional and each solve the issue presented. I think decided to move to C++11 and use an assert for this particular case. In the future I think I will add a template to the function and ensure to get the data that way. Thank you all for the help! I have marked what I think is the best answer although each have been acceptable.

Answer 1

You are getting the error because despite that FFTWImageTile is derived from ImageTile , TileGrid<FFTWImageTile> and TileGrid<ImageTile> are absolutely unrelated classes.

How to fix this depends on the implementation of the classes which you haven't shown. Perhaps you can make writeDataToFile() templated:

template<typename T>
void writeDataToFile(TileGrid<T> * grid, std::string fileName);

Answer 2

You generate two different classes with

TileGrid<ImageStitching::ImageTile>

and

TileGrid<is::FFTWImageTile>

They have no relation other than being generated from the same template. You would want to derive from the class TileGrid<ImageStitching::ImageTile> to have an actual subclass for type purposes.

You could templatize the function writeDataToFile , but to enforce type restrictions on template arguments, you should use something like...

static_assert(is_base_of<T, ImageStitching::ImageTile>>(), "T is not a base of ImageTile");

• static_assert
• is_base_of

Answer 3

Options that might work for you.

1. Make writeDataToFile a function template.

    template <typename T> void writeDataToFile(TileGrid<T> * grid, std::string fileName); 

   In the implementation of this function, use another function template to write individual elements of the tile.

    template <typename T> void writeTileElement(T const& tileElement, std::ostream& out); 

   You can create overloaded versions of writeTileElement to take care of special handling of different types of objects.

2. Use a TileGrid of ImageTile* instead of ImageFile .

    void writeDataToFile(TileGrid<ImageStitching::ImageTile*> * grid, std::string fileName);