Link problem with template in Visual C++ 2005 Express

[2beagles]

I have a template for a three dimensional array that I have been working on using Visual C++ 6.0. Under version 6 this code worked fine. However, last night I downloaded Visual C++ 2005 Express and and trying to get the same code to work. Under Visual C++ 2005 I am seeing linker errors. The problem is in the definition of a couple of friend operators that the linker does not like for some reason. I am assuming I have a mistake in my definitions and that Visual C++ 2005 is just pickier about it than the old vers. 6 was. I just can not seem to find the issue.

My template definition is,

template <class type>
class Array
{
    private:
        type* data;
        unsigned int iMax;
        unsigned int jMax;
        unsigned int kMax;
 
    public:
        Array()
        {
            data = 0;
        }
 
        Array(const Array<type>& _obj)
        {
            iMax = _obj.iMax;
            jMax = _obj.jMax;
            kMax = _obj.kMax;
 
            data = new type[iMax * jMax * kMax];
            for (unsigned int ijk = 0; ijk < iMax * jMax * kMax; ijk++)
            {
                data[ijk] = _obj.data[ijk];
            }
        }
 
        Array(const unsigned int _iMax, const unsigned int _jMax, const unsigned int _kMax)
        {
            iMax = _iMax;
            jMax = _jMax;
            kMax = _kMax;
 
            data = new type[iMax * jMax * kMax];
        }
 
        ~Array()
        {
            if (data != 0)
            {
                delete [] data;
                data = 0;
            }
        }
 
        Array<type>& operator=(const Array<type>& rhs)
        {
            if (&rhs != this)
            {
 
                iMax = rhs.iMax;
                jMax = rhs.jMax;
                kMax = rhs.kMax;
 
                if (data!= 0)
                {
                    delete [] data;
                }
 
                data = new type[iMax * jMax * kMax];
                for (unsigned int ijk = 0; ijk < iMax * jMax * kMax; ijk++)
                {
                    data[ijk] = rhs.data[ijk];
                }
            }
 
            return *this;
        }
 
        Array<type>& operator=(const type& rhs)
        {
            for (unsigned int ijk = 0; ijk < iMax * jMax * kMax; ijk++)
            {
                data[ijk] = rhs;
            }
 
            return *this;
        }
 
        friend Array<type> operator+(const type& lhs, const Array<type>& rhs);
        friend Array<type> operator-(const type& lhs, const Array<type>& rhs);
};
 
template <class type>
Array<type> operator+(const type& lhs, const Array<type>& rhs)
{
    Array<type> newMat(rhs);
 
    for (unsigned int ijk = 0; ijk < newMat.iMax * newMat.jMax * newMat.kMax; ijk++)
    {
        newMat.data[ijk] += lhs;
    }
 
    return newMat;
}
 
template <class type>
Array<type> operator-(const type& lhs, const Array<type>& rhs)
{
    Array<type> newMat(rhs);
 
    for (unsigned int ijk = 0; ijk < newMat.iMax * newMat.jMax * newMat.kMax; ijk++)
    {
        newMat.data[ijk] = lhs - newMat.data[ijk];
    }
 
    return newMat;
}
 

and I am calling the operators from a simple test routing,

#include "Array.h"
 
int main(int argc, char* argv[])
{
    Array<int> a0_t4(3, 3, 1);
    a0_t4 = 2;
    Array<int> a2_t4;
    a2_t4 = 1 + a0_t4;
    a2_t4 = 1 - a0_t4;
 
    return 0;
}
 

The errors I am getting from the linker are,

Error 1 error LNK2019: unresolved external symbol "class Array<int> __cdecl operator-(int const &,class Array<int> const &)" (??G@YA?AV?$Array@H@@ABHABV0@@Z) referenced in function _main TestFlow.obj
Error 2 error LNK2019: unresolved external symbol "class Array<int> __cdecl operator+(int const &,class Array<int> const &)" (??H@YA?AV?$Array@H@@ABHABV0@@Z) referenced in function _main TestFlow.obj
Error 3 fatal error LNK1120: 2 unresolved externals C:\Documents and Settings\sstanley\Desktop\cppPlaying\TestFlow\Debu g\TestFlow.exe


Can anyone tell me what I am doing wrong in these operators?

[2beagles]

My apologies. I seem to have posted this under articles by accident. I will repost under forums.

[JosAH]

My apologies. I seem to have posted this under articles by accident. I will repost under forums.

I'll move your thread to the C/C++ Forum section for you; no problem.

kind regards,

Jos

[weaknessforcats]

This has to do with bound vs unbound friend function templates.

That is, if you have an Array<int> your friend declatation must be Array<int> and not Array<type>. This is ean example of a bound friend template. Only Array<int> has the operator+ defined.

If you want an operator+ created for all Array<type>, then the friend function must be defined inside the class defintion.

Here is your code in a working condition as far as compile and link goes:

#include <iostream>
using namespace std;
 
template <class type>
class Array
{
    private:
        type* data;
        unsigned int iMax;
        unsigned int jMax;
        unsigned int kMax;
 
    public:
        Array()
        {
            data = 0;
        }
 
        Array(const Array<type>& _obj)
        {
            iMax = _obj.iMax;
            jMax = _obj.jMax;
            kMax = _obj.kMax;
 
            data = new type[iMax * jMax * kMax];
            for (unsigned int ijk = 0; ijk < iMax * jMax * kMax; ijk++)
            {
                data[ijk] = _obj.data[ijk];
            }
        }
 
        Array(const unsigned int _iMax, const unsigned int _jMax, const unsigned int _kMax)
        {
            iMax = _iMax;
            jMax = _jMax;
            kMax = _kMax;
 
            data = new type[iMax * jMax * kMax];
        }
 
        ~Array()
        {
            if (data != 0)
            {
                delete [] data;
                data = 0;
            }
        }
 
        Array<type>& operator=(const Array<type>& rhs)
        {
            if (&rhs != this)
            {
 
                iMax = rhs.iMax;
                jMax = rhs.jMax;
                kMax = rhs.kMax;
 
                if (data!= 0)
                {
                    delete [] data;
                }
 
                data = new type[iMax * jMax * kMax];
                for (unsigned int ijk = 0; ijk < iMax * jMax * kMax; ijk++)
                {
                    data[ijk] = rhs.data[ijk];
                }
            }
 
            return *this;
        }
 
        Array<type>& operator=(const type& rhs)
        {
            for (unsigned int ijk = 0; ijk < iMax * jMax * kMax; ijk++)
            {
                data[ijk] = rhs;
            }
 
            return *this;
        }
 
       // bound
        friend Array<int> operator+(int lhs, Array<int> rhs);
       //unbound
        friend Array<type> operator-(const type& lhs, const Array<type>& rhs)
        {
             Array<type> newMat(rhs);
 
              for (unsigned int ijk = 0; ijk < newMat.iMax * newMat.jMax * newMat.kMax; ijk++)
              {
                 newMat.data[ijk] = lhs - newMat.data[ijk];
              }
 
          return newMat;
        }
};
 
//template <class type>
//Array<type> operator+(const type lhs&, const Array<type>& rhs)
Array<int> operator+(int lhs, Array<int> rhs)
{
    Array<int> newMat(rhs);
 
    for (unsigned int ijk = 0; ijk < newMat.iMax * newMat.jMax * newMat.kMax; ijk++)
    {
        newMat.data[ijk] += lhs;
    }
 
    return newMat;
}
 
template <class type>
Array<type> operator-(const type& lhs, const Array<type>& rhs)
{
    Array<type> newMat(rhs);
 
    for (unsigned int ijk = 0; ijk < newMat.iMax * newMat.jMax * newMat.kMax; ijk++)
    {
        newMat.data[ijk] = lhs - newMat.data[ijk];
    }
 
    return newMat;
}
 
 
//and I am calling the operators from a simple test routing,
 
 
//Code: ( text )
//#include "Array.h"
 
int main(int argc, char* argv[])
{
    Array<int> a0_t4(3, 3, 1);
    a0_t4 = 2;
    Array<int> a2_t4;
 
    a2_t4 = 1 + a0_t4;
    a2_t4 = 1 - a0_t4;
 
    return 0;
}
 

[2beagles]

If you want an operator+ created for all Array<type>, then the friend function must be defined inside the class definition.

Interesting. So, declaring the friend function inside of the class definition template is not enough. The actual function must be defined inside of the class template.

Thanks for the help.

[weaknessforcats]

So, declaring the friend function inside of the class definition template is not enough. The actual function must be defined inside of the class template.

This is due to how templates work. You can't use a function prototype as a template. The compiler is not able to seek out the template specializations. So, you either specialize the template yourself and put the function prototype of the specialized template in the class (bound) or you have to put the entire friend template in the class (unbound).

When export templates are finally used, this restriction will go away. Currently, I don't know a a compiler that supports export templates.