A::A(A a)
{
...
}

12.8.2 A nontemplate constructor for class X is a copy constructor if its first parameter is of type X&, const X&,
volatile X& or const volatile X&, and either there are no other parameters or else all other
parameters have default arguments (8.3.6).106) [Example: X::X(const X&) and X::X(X&, int=1)
are copy constructors.

class X {
// ...
public:
X(int);
X(const X&, int = 1);
};
X a(1); // calls X(int);
X b(a, 0); // calls X(const X&, int);
X c = b; // calls X(const X&, int);

—end example] [Note: all forms of copy constructor may be declared for a class. [Example:

class X {
// ...
public:
X(const X&);
X(X&); //OK
};

—end example] —end note] [Note: if a class X only has a copy constructor with a parameter of type X&,
an initializer of type const X or volatile X cannot initialize an object of type (possibily cvqualified)
X. [Example:

struct X {
X(); //default constructor
X(X&); //copy constructor with a nonconst parameter
};
const X cx;
X x = cx; // error – X::X(X&) cannot copy cx into x
—end example] —end note]

H>>Теперь, думаю, я это запомню на всю жизнь

A& A::operator=(const A &a)
{
...
}

H>>Так... пишу по памяти

H>>A& A::operator=(const A &a)
H>>{
H>>......// А тут что?
H>>}
H>>

return *this;

КД>>Навеяло... а то, как пишется нормальный оператор копирования, я понял еще через пару лет

T& T::operator = (const T& x)
{
 this->a1 =  x.a1;
 this->a2 =  x.a2;
 this->a3 =  x.a3;
 this->a4 =  x.a4;

 return *this;
}//T::copy operator

T& T::operator = (const T& x)
{
 T tmp(x); // Copy constructor

 this->swap(tmp); // NO EXCEPTIONS !!!

 return *this;
}//T::copy operator

H>>>Так... пишу по памяти

H>>>A& A::operator=(const A &a)
H>>>{
H>>>......// А тут что?
H>>>}
H>>>

return *this;

A& A::operator=(const A &a)
{
   if (a != *this)
    {
       ....   
    }
  return *this;
}

S>A& A::operator=(const A &a)
S>{
S>   if (a != *this)
S>    {
S>       ....   
S>    }
S>  return *this;
S>}
S>

A& A::operator=(const A &a)
{
   if (this != &a)
   {
      ....
   }
  return *this;
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1 {
    class Program {
    
        static void Main(string[] args) {
            
            const int c = 10;
            int[] A = new int[c] {12, 123, 534, 123, 76, 34, 56, 23, 67, 34};
            //qsort((void*)A, (size_t)A, sizeof(int), compare);
            for (int i = 0; i < c; i++) {
                for (int j = i; j < c; j++) {
                    if (A[i] < A[j]) {
                        
                        int buf = A[i];
                        A[i] = A[j];
                        A[j] = buf;
                    }
                }
            }

            for (int i = 0; i < c; i++) {
                Console.WriteLine(A[i]);
            }            
        }
        /*
        int compare( const void *arg1, const void *arg2 )
        {            
            return _stricmp( * ( char** ) arg1, * ( char** ) arg2 );
        }
        */
    }
}

T& T::operator = (const T& x)
{
 T tmp(x); // Copy constructor

 this->swap(tmp); // NO EXCEPTIONS !!!

 return *this;
}//T::copy operator

class T
{
 private:
  typedef T     self_type;
 
  T(const self_type&);
  self_type& operator = (const self_type&);

 public:
  //Тут, типа, что-угодно
};//class T

swap

template<class _Ty> inline
    void swap(_Ty& _Left, _Ty& _Right)
    {    // exchange values stored at _Left and _Right
    _Ty _Tmp = _Left;
    _Left = _Right, _Right = _Tmp;
    }

 this->a1 =  x.a1;
 this->a2 =  x.a2;
 this->a3 =  x.a3;
 this->a4 =  x.a4;

Правда в последнее время, мне в голову все чаще и чаще приходя мысли, что проектировать классы нужно так, чтобы у них вообще не было реализаций конструкторов и операторов копирования.

Выносишь состояние объекта в отдельный класс, объекты которого создаются динамически (в куче).

КД>class T
КД>{
КД> private:
КД>  typedef T     self_type;
 
КД>  T(const self_type&);
КД>  self_type& operator = (const self_type&);

КД> public:
КД>  //Тут, типа, что-угодно
КД>};//class T
КД>

#include <boost/utility.hpp>

class T : boost::noncopyable
{
...

КД>Вообще говоря, вы бы лучше маленький пример "правильного оператора копирования" привели... А то мне кажется что вы просто пытаетесь придавить меня интеллектом

class Safe
{
  Object obj; // Object должен иметь безопасные конструктор копирования и оператор копирования
  std::string str;

public:
  Safe(const Safe& rhs) : obj(rhs.obj), str(rhs.str) {}
  Safe& operator= (const Safe& rhs)
  {
    Safe tmp(rhs);
    std::swap(obj, tmp.obj);
    std::swap(str, tmp.str);
    return *this;
  }
};

IM>Нет, совершенно не пытаюсь. Просто у вас тут уже целая ветка выросла из-за непонимания. Вот мне и стало интересно. Мне сейчас вообще кажется, что мы с вами говорим об одном и том же, просто вы что-то не договариваете.

class Safe
{
 //...
}