Suppose I have an abstract base class that looks like this:

template <typename T>

class base {

public: // Typedefs

typedef double value_type;

typedef std::size_t size_type;

public:

// Assignment operators.

virtual base<T>& operator=(const base<T>& rhs) = 0;

virtual base<T>& operator=(const value_type& rhs) = 0;

// Indexing operators.

virtual value_type& operator()(size_type i, size_type j) = 0;

virtual const value_type& operator()(size_type i, size_type j) const

= 0;

// Size functions.

virtual size_type size() const = 0;

virtual size_type rows() const = 0;

virtual size_type columns() const = 0;

// Elementwise mathematical operators

virtual base<T>& operator+=(const base<T>& rhs) = 0;

virtual base<T>& operator-=(const base<T>& rhs) = 0;

virtual base<T>& operator*=(const base<T>& rhs) = 0;

virtual base<T>& operator/=(const base<T>& rhs) = 0;

virtual base<T>& operator+=(const value_type& rhs) = 0;

virtual base<T>& operator-=(const value_type& rhs) = 0;

virtual base<T>& operator*=(const value_type& rhs) = 0;

virtual base<T>& operator/=(const value_type& rhs) = 0;

};

and a derived class:

template <typename T>

class image : public base<T> {

protected: // Data members

value_type *m_data;

size_type m_rows, m_columns;

public:

// Constructors and destructor.

image();

image(size_type m, size_type n);

image(size_type m, size_type n, const value_type& init);

image(const image<T>& rhs);

~image();

// Assignment operators.

image<T>& operator=(const base<T>& rhs);

image<T>& operator=(const value_type& rhs);

// Indexing operators.

value_type& operator()(size_type i, size_type j);

const value_type& operator()(size_type i, size_type j) const;

// Size functions.

size_type size() const;

size_type rows() const;

size_type columns() const;

// Elementwise mathematical operators

image<T>& operator+=(const base<T>& rhs);

image<T>& operator-=(const base<T>& rhs);

image<T>& operator*=(const base<T>& rhs);

image<T>& operator/=(const base<T>& rhs);

image<T>& operator+=(const value_type& rhs);

image<T>& operator-=(const value_type& rhs);

image<T>& operator*=(const value_type& rhs);

image<T>& operator/=(const value_type& rhs);

};

When i want to use the assignment operator in my code, even a simple

program won't compile:

int main(void)

{

image<double> im1(512,512), im2(512,512);

im1 = im2;

return 0;

}

With VC7.1 I receive this error message:

main.obj : error LNK2019: unresolved external symbol "public: virtual

class image::base<double> & __thiscall

image::base<double>::operator=(class image::base<double> const &)"

(??4?$base@N@image@@UAEAAV01@ABV01@@Z) referenced in function "public:

class image::image<double> & __thiscall

image::image<double>::operator=(class image::image<double> const &)"

(??4?$image@N@image@@QAEAAV01@ABV01@@Z)