copy constructor and templated class

[xargon]

Hello everyone,

I have a class declaration as follows:

template<typename T>
class Matrix
{
};

Now, I want to have a copy constructor. Can I do something like this?

template<typename Y>
Matrix(const Matrix<Y> & rhs)
{
}

When I do something like this in my program:

Matrix<float> mat1;
Matrix<float> mat2 = mat1;

It seems to be calling the default compiler generated copy constructor. I am guessing there are some subtelties to copy constructor and templated classes. Do I need to specify a separate copy constructor when the object templates are of the same type?

Many thanks,

/x

[guestgulkan]

Because Matrix<float> mat2 = mat1; is assignment not copy constructing

[jsmith]

Nope.

The above "copy constructor" is not a copy constructor.

The copy constructor is declared as:

Matrix( const Matrix<T>& rhs );

which is not the same thing as what you wrote.

If Y == T, then yes, your constructor is a copy constructor. However to the compiler the default copy constructor looks like a specialization that binds tighter than your constructor. Hence the compiler chooses
to call the default copy constructor.

[Denis]

template<typename T>
class Matrix
{
public:
Matrix(const Matrix<T>& rhs);
};

[Hammurabi]

It should go something like this:

#include <iostream>

template<typename T>
class Matrix
{
public:
    Matrix();
    Matrix(const Matrix & rhs);
};

template<typename U>
Matrix<U>::Matrix()
{
    std::cout << "Default ctor\n";
}

template<typename V>
Matrix<V>::Matrix(const Matrix & rhs)
{
    std::cout << "Copy ctor\n";
}

int main()
{
    Matrix<float> mat1;
    Matrix<float> mat2 = mat1;
}

[xargon]

Hey,

Thanks everyone for the replies. I now understand that a proper copy constructor has to be defined.

I have just one follow up question. I also want to define a constructor where the RHS can have a implicit convertible type. So that I could convert between the data types (say between float and integers).

So, I have something like following:

template<typename Y>
Matrix<T>(const Matrix<Y> & rhs)
{
    m_rows = rhs.m_rows; // Problem: Cannot access private member m_rows
    m_cols = rhs.m_cols; // same problem.
}

The idea is later I can do:

Matrix<float> mat1;
//
Matrix<int> mat2 = mat1;

In this case, the compiler complains that it cannot access the private member m_rows for the RHS. I am a bit confused as to why this should be. If I access the member through some public function, it is ok. I am wondering why this should cause a problem and if there is something that I can do in the class definition that would make such an implicit conversion possible.

Thanks,

/x

[jsmith]

They are not the same type.

It is just as if Matrix<Y> were Foo instead. Matrix<> is not allowed to access private/protected elements of Foo unless Matrix is a friend of Foo.

You will need to provide accessors.