Question

First of all, I know that one has to implement the definition in the header files, and that’s what I generally did according to this thread

I have several files

// Image.h
namespace library
{
    namespace data
    {
        template<class Pixel, class SubPixel, int Layer>
        class Image 
        {
            public:
            Image(int width, int height, Pixel emptyFill);
            Image(int width, int height);
            ~Image();

            Pixel& operator() (int x, int y);
            const Pixel& operator() (int x, int y) const;
            SubPixel& operator() (int x, int y, int subpixel);
            const SubPixel& operator() (int x, int y, int subpixel) const;

            protected:
            int m_width;
            int m_height;

            Pixel* m_pixels;
            void init(Pixel emptyFill);
            bool checkBounds(int x, int y, int layer = 0) const;

            virtual SubPixel& pixelToSubpixel(Pixel& pixel, int layer) const = 0;
        };

        template<class Pixel, class SubPixel, int Layer>
        Image<Pixel, SubPixel, Layer>::Image(int width, int height)
        : m_width(width), m_height(height), m_pixels(new Pixel(width * height))
        {
            init(0);
        }

        template<class Pixel, class SubPixel, int Layer>
        Image<Pixel, SubPixel, Layer>::~Image()
        {
            delete m_pixels;
        }


        template<class Pixel, class SubPixel, int Layer>
        Pixel& Image<Pixel, SubPixel, Layer>::operator() (int x, int y)
        {
            // implementation ...
        }

        template<class Pixel, class SubPixel, int Layer>
        const Pixel& Image<Pixel, SubPixel, Layer>::operator() (int x, int y) const
        {
            // implementation ...
        }

        template<class Pixel, class SubPixel, int Layer>
        SubPixel& Image<Pixel, SubPixel, Layer>::operator() (int x, int y, int subpixel)
        {
            // implementation ...
        }

        template<class Pixel, class SubPixel, int Layer>
        const SubPixel& Image<Pixel, SubPixel, Layer>::operator() (int x, int y, int subpixel) const
        {
            // implementation ...
        }

        template<class Pixel, class SubPixel, int Layer>
        void Image<Pixel, SubPixel, Layer>::init(Pixel emptyFill)
        {
            // implementation ...
        }

        template<class Pixel, class SubPixel, int Layer>
        inline bool Image<Pixel, SubPixel, Layer>::checkBounds(int x, int y, int subpixel) const
        {
            // implementation
        }

    }



}


// DepthImage.h:
namespace library
{
    namespace data
    {
        template class Image<unsigned short, unsigned short, 1>;
        class DepthImage : public Image<unsigned short, unsigned short, 1>
        {
            public:
            DepthImage(int width, int heigth);
            DepthImage(int width, int heigth, unsigned short emptyfill);
            ~DepthImage();

            protected:

            virtual unsigned short& pixelToSubpixel(unsigned short& pixel, int layer) const;
            private:
            DepthImage();

        };

    }
}

The whole thing is compiled to a shared object library. This works fine.

As soon as I try to link an executable object against this .so-file, I receive:

library.so: undefined reference to `library::data::Image<unsigned short, unsigned short, 1>::Image(int, int, unsigned short)'
collect2: ld returned 1 exit status

I even thought to make a explicit template instanciation at DepthImage.h. As DepthImage is not a templated class (it’s just extending one), I don’t understand the problem.

Any idea??

Regards, Tobias

Answer 1

You have not provided a definition for Image(int width, int height, Pixel emptyFill);, only for Image(int width, int height);