[C++] costruttori di copia e operatori assegnamento problem :-(

[Zero-Giulio]

Ecco un breve pezzo di codice con una classe che sto scrivendo



template <typename T>
class array {

template <typename U>
friend class array;

friend ostream & operator << (ostream & os, const array <T> & v) {
cout << endl;
for (unsigned int i = 0; i < v.num_; i++)
cout << v.ptr [i] << " ";
for (unsigned int i = v.num_; i < v.size_; i++)
cout << "? ";
cout << endl;
return os;
}

public:

explicit array (const unsigned int & s)
: incr_ (s)
, size_ (s)
, num_ (0) {
alloc ();
}

explicit array (const unsigned int & s, const unsigned int & i)
: incr_ (i)
, size_ (s)
, num_ (0) {
if (incr_ < 1) {
arrayWarning ("in array constructor: incr_ must be a >= 1 unsigned int");
incr_ = 1;
}
alloc ();
}

template <typename U>
array (const array <U> & a)
: incr_ (a.incr_)
, size_ (a.size_)
, num_ (a.num_) {
alloc ();
for (unsigned int i = 0; i < num_; i++)
ptr [i] = static_cast <T> (a.ptr [i]);
}

~array () {
delete [] ptr;
}

template <typename U>
bool operator != (const array <U> & a) const {
if (num_ != a.num_)
return true;
for (unsigned int i = 0; i < num_; i++)
if (ptr [i] != a.ptr [i])
return true;
return false;
}

template <typename U>
bool operator == (const array <U> & a) const {
return !(*this != a);
}

template <typename U>
const array <T> & operator = (const array <U> & a) {
if (size_ < a.num_)
add (a.size_);
num_ = a.num_;
for (unsigned int i = 0; i < num_; i++)
ptr [i] = static_cast <T> (a.ptr [i]);
return *this;
}

template <typename U>
array <T> & in (const U & u) {
add (1);
ptr [num_++] = static_cast <T> (u);
return *this;
}

template <typename U>
array <T> & in (const array <U> & a) {
unsigned int n = a.num_;
add (n);
for (unsigned int i = 0; i < n; i++)
ptr [num_++] = static_cast <T> (a.ptr [i]);
return *this;
}

unsigned int setIncr (const unsigned int & i) {
unsigned int dummie = incr_;
if (i < 1)
arrayWarning ("in setIncr: function parameter must be a >= 1 unsigned int");
else
incr_ = i;
return dummie;
}

unsigned int incr () const {
return incr_;
}

unsigned int size () const {
return size_;
}

unsigned int num () const {
return num_;
}

private:

void alloc () {
if (size_ < 1)
arrayError ("in array constructor: size_ must be a >= 1 unsigned int");
try {
ptr = new T [size_];
}
catch (bad_alloc & err_msg) {
arrayAllocationError (Str (size_));
}
}

void add (const unsigned int & n) {
unsigned int min_size = num_ + n;
if (size_ < min_size) {
size_ = max (size_ + incr_, min_size);
T * new_ptr;
try {
new_ptr = new T [size_];
}
catch (bad_alloc & err_msg) {
arrayAllocationError (Str (size_));
}
for (unsigned int i = 0; i < num_; i++)
new_ptr [i] = ptr [i];
delete [] ptr;
ptr = new_ptr;
}
}

unsigned int incr_;
unsigned int size_;
unsigned int num_;
T * ptr;

};



Come potete vedere, ci sono costruttori, costruttori di copia, operatori relazionali e di assegamento e altro.
Il costruttore di copia e quello di assegnamento sono scritti come template.
Mi domando se questo crei problemi.

Il punto è questo:

1) se faccio

array <double> a1 (4);
array <double> a2 (8);

a2 = a1

il codice funziona (a2 mantiene size_ e incr_ e riceve da a1 num_ e i primi num_ elementi di ptr).

2) se invece ho

array <double> a1 (4);
array <double> a2 (8);

a2 = a1

il codice non funziona (a2 riceve anche size_ e incr_ da a1).
Ho cercato di debuggare il codice cercando di capire perchè questo succedesse e ho scoperto che
l'operazione a2 = a1 NON chiama nè il mio operatore di assegnamento, nè altri mie funzioni.
Ho messo delle cout dentro tutta la mia classe ma niente.
Se scrivo a2 = a1, con i tipi di a1 e a2 uguali, viene invocato qualcosa che io non ho scritto.

Ora io mi domando, sarà mica che quello scemo del compilatore invoca un qualche costruttore implicito o
qualche operatore che solo lui sa (quelli che invoca quando un utente non li crea per intenderci)?
Oppure sono io lo scemo e c'è qualcosa che non so?

E nel caso il compilatore usasse qualcosa di suo... Perchè lo fa?
E' per via del fatto che io ho usato i template?

Ma se io scrivo

template <typename U> const array <T> & operator = (const array <U> & a)

non dovrei avere come caso particolare anche

const array <T> & operator = (const array <T> & a)

???

Non capisco.

P.S.: se aggiungo un costruttore di copia e un operatore di assegnamento senza i template tutto funziona.
E' solo che non piace riempire il codice di funzioni ridondanti. Insomma,

const array <T> & operator = (const array <T> & a)

dovrebbe essere un caso particolare di

template <typename U> const array <T> & operator = (const array <U> & a)

no?
Perchè doverli scrivere entrambi???