Copy Constructor

Despite the marketing reasons every one can expose (self-generated copy copy constructor existi because are good to ... or because it would be bad to ...) the history has a clear answer.
After C++ introduced the concept of "objects" and made the struct to fall into it together with the classes, that was the sole way to retain C semantical compatibility about the copy and assignment of structs.

In C, if you have

struct A { int x; };
A function() { A a; a.x=1; return a; }
A a1;

You must be able to compile

a1 = function();

That requires the local a to be copied into a temporary residing in the outer scope to be soon later assigned to the a1 variable.
Without copy and assignment operations, plain C programs could not be compiled by C++.

Whether it was a good or bad choice extending this behavior to classes ... that's all another problem.

A compiler provides default constructor which is a parameterless and a default copy constructor which does shallow copy.

class MyClass {
    int A, B;
public:
    MyClass() {}
    MyClass(MyClass &src) : A(src.B), B(src.A) { }
    MyClass(int a, int b) : A(a), B(b) { }
};
//...

MyClass c0;
MyClass c1(2, 4);
MyClass c2 = c1;

If first two constructors are not supplied, they are assumed by default.
To initialize c0, you need first one, parameterless, to initialize c1, you need a constructor with 2 parameters (no default), to initialize c2
you need a copy constructor (A and B swapped intentionally), if you comment a copy constructor out, it will compile anyway (because the default works in this case), and A will go to A, B to B. :-)

The default constructor (the one without parameters) can be disabled by providing some dummy constructor and making it private. This is a known way artificially disable the ability to construct an instance at all -- especially needed because there are no notion of abstract class in C++

The compiler provides a default constructor if you don't write one explicitly for a couple of reasons:

- it's handy, if you hold everything by value then you can rely on the default constructor and woo-hoo, it all works

- C works this way. When you copy a struct in C does the compiler does a memcpy which has the same effect for built in types and PODs that a copy constructor has

Cheers,

Ash

PS: Just read Emilio's answer, he made the point I wanted to make, so move along, nothing to see here...

The copy constructor is necessary for certain operations on STL collections. However, if you forgot to customize your copy constructor and the default copy constructor is utilized, you will find yourself needlessly wasting time on debugging. It is a much better practice to make the default copy constructor private and only make customized copy constructors public. Two minutes of laziness can cost you hours of maintenance.

Only if the class is essentially a struct would I consider utilizing a default copy constructor...