Question

Let’s suppose that I have a class container:

template<class T, int size>
class container
{
private:
    T* data;
    int length;
public:
    container()
    {
        data=new T[size];
        length=size;
    }
    ~container()
    {
        if(length>0)
            delete[] data;
    }
    container& operator= (container<T,size> c)
    {
        if(length>0)
           delete[] data;
        data=new T[c.length];
        length=c.length;
        for(int i=0; i<length; i++)
            data[i]=c.data[i];
        return *this;
    }
};

The problem is that if I have two container of different size, I can’t use the = operator to assign one to the other.For example:

container<int,4> c1;
container<int,5> c2;
c1=c2;  // syntax error: 4!=5

Classes like c++11 array allow to do this.
How to do that?

Answer 1

Templates are just that — templates the compiler uses to make classes, not classes themselves.

Thus, container<int,4> and container<int,5> are completely separate classes, with all of the access restrictions that implies.

In particular, this means that container<int, 4>‘s assignment operator cannot access the private memebers of container<int,5>.

There are a few ways to get around this:

• Eliminate the size template argument, since as others have noted, you seem to be allocating memory dynamically, so nailing down the size at compile time isn’t adding any value, and in fact could be misleading since your assignment operator could result in a different size than the one declared.
• Implement your assignment operator in terms of container‘s public interface.
• Declare all container classes of the same type as friends by adding the following line to your class:

Code:

template<class U, int otherSize> friend class Foo;

and declaring your assignment operator as follows:

template <int otherSize>
container<T,size>& operator=(container<T,otherSize> c);