Need of copy constructor

Actually in the second case, you are using the assignment operator. Again, just like the copy constructor, if you do not write an assignment operator then the compiler will generate one for you. The compiler generated assignment operator will be like the following:

ClassA& operator=(const ClassA& rhs)
{
  aVar = rhs.aVar;
  return *this;
}

Whever you write

class A
{
    int m;
};

The compiler will do

class A
{
    int m;
public:
    A() :m() {} 
    A(const A& a) :m(a.m) {}
    A& operator=(const A& a) { m=a.m; return *this; }
    ~A() {}
};

hence, unless you explicitly declare one or all of those function as private, things like
a1 = a2;
return a;
fn(a);
will always implicitly resolve to the compiler generated default.

There is people who think it would be better if such "autogenerated things" woludn't be there, but this way, an old C99 struct cannot copy.

Well look buddy!!! a copy constructor and assignment operator (via operator overloading) as well as default constructor and destructor are by default created for you whenever you define a class in C++.

Then why do we need to define them ourselves?

One and a simple answer to let it happened in our own way!!!
How we like these things to be done, just make it...

A default copy constructor and assignment operator are used to make shallow copy of the assigned object!!!
but you can override this ongoing default behavior by using your own defined/customized behavior which is needed in many situation.

For example:
<pre>class A
{
public:
int* a;
int b;
A()
{
b = 10;
a = &b;
}
}

int main()
{

A a1 = new A();
A a2(a1); //copy construction
delete a1;
cout << *(a2.b); //will produce an error
return 0;
}</pre>

because in shallow copy a2.a = a1.a = address of a1.b, now a1 is destroyed so address of a1.b is no longer valid.

This kind of problem can be omitted using your own copy constructor.
just add the following copy constructor to definition of A:
<pre>
A& A(const A& a1)
{
b = a1.b;
a = &b;
return &this;
}
</pre>
Hope it will help you !!! :)

A copy constructor is needed in order to initialize this object with a copy of the input object. Event if your 'other constructor' (i.e. A(int tmp)) do basically the same, the compiler doesn't know that and won't use it.
For instance, without a copy constructor. you couldn't do the following:

A a1;
A a2(a1);

(nor even:

A a2=a1;

)

Please note: as other have already pointed out, the compiler gently provides a default copy constructor for you, but this is a technical artifact that has nothing to do with the above distinction.