Template copy constructor question.

[ravajappa.gouda]

Hi! Can somebody tell me when does copy constructor 1 or 2 gets called
in a template class below? And if you can explain the difference
between the 1 and 2 below would be great?


template<typename T, size_t size>
class container {

public:
container() //default constructor.
{
}

template<typename cT, size_t cs> // Copy
constructor 1
container(const container<cT, cs>& rhs)
{
........
}

container(const container& rhs) // Copy
constructor 2
{
...........
}


private: ..... //
private members defined here.
};

 

[peter koch]

Hi! Can somebody tell me when does copy constructor 1 or 2 gets called
in a template class below? And if you can explain the difference
between the 1 and 2 below would be great?

template<typename T, size_t size>
class container {

public:
  container()   //default constructor.
  {
  }

  template<typename cT, size_t cs>                    // Copy
constructor 1
  container(const container<cT, cs>& rhs)
  {
      ........
  }

  container(const container& rhs)                        // Copy
constructor 2
  {
..........
  }

private: .....                                                             //
private members defined here.



}

The second constructor is the default copy-constructor and will be
called whenever a normal copy constructor would normally be called.
The first one will be called in the other cases - that is if cT is
different from T or cs is different from size.
You do need the second constructor if it behaves differently from what
the compiler would generate: the templated copy constructor will never
be a substitute for the default constructor and thus you need to
supply it.

/Peter

 

[Andrey Tarasevich]

Can somebody tell me when does copy constructor 1 or 2 gets called
in a template class below?

This question is already incorrect by itself. There's only one copy
constructor in your class. It is constructor 2. Template 1 does not
define any copy constructors. It can be used to generate _conversion_
constructors, but not copy constructors.

And if you can explain the difference
between the 1 and 2 below would be great?

I don't really see what needs to be explained here. These constructors
take arguments of different types. So the right one will be chosen
depending on the type of the argument used during construction. That's
basically it.

 

[James Kanze]

The second constructor is the default copy-constructor and
will be called whenever a normal copy constructor would
normally be called.

That's not quite true. The only real effect of the second
(other than those associated with any constructor) is to
suppress the automatic generation of the copy constructor by the
compiler. In any given situation, which constructor is called
will depend on operator overload resolution, and it is quite
possible to design a class so that the template constructor is
called for copying. (Admittedly, this is a rather exotic point,
and it's not likely to affect most people's code.)

 

[peter koch]

That's not quite true.  The only real effect of the second
(other than those associated with any constructor) is to
suppress the automatic generation of the copy constructor by the
compiler.  In any given situation, which constructor is called
will depend on operator overload resolution, and it is quite
possible to design a class so that the template constructor is
called for copying.  (Admittedly, this is a rather exotic point,
and it's not likely to affect most people's code.)

While I was aware of your first point, your second point is new to me.
Could you give me an example of how to write the copy-constructor in a
way that it will not be called to construct an object from an object
of the same type, using my generic templated constructor instead? I
have wanted to do so a few times but thought it was not possible and
instead ended up with two identical pieces of code.

/Peter