Why must the parameter of a copy constructor be a reference?

A copy constructor is a constructor that initializes an object by creating a copy of another object of the same class. It has the following general form: ``` ClassName(ClassName &source_object); ``` Here, "ClassName" is the name of the class and "source_object" is a reference to the object being copied.

The parameter of a copy constructor must be a reference because if it were not, we would have to pass the object by value. Passing an object by value would require creating a copy of the object. However, in order to create a copy, the copy constructor needs to be called. This would lead to an infinite loop of calling the copy constructor and creating more copies. By using a reference, we avoid this infinite loop because a reference does not create a new object, but rather refers to the memory location of the existing object.

Consider the following class with a copy constructor that accepts a reference: ```cpp class MyClass { public: int a; // Regular constructor MyClass(int value) : a(value) {} // Copy constructor with reference parameter MyClass(const MyClass &obj) { a = obj.a; } }; int main() { MyClass original(5); // Regular constructor called MyClass copy(original); // Copy constructor called with reference parameter } ``` In this example, when creating the `copy` object, the copy constructor is called, and it accepts a reference to the `original` object. This avoids the infinite loop problem, as the reference simply points to the memory location of the existing object, and no new object is created in the process.

If we attempted to use a non-reference parameter, the copy constructor would look like this: ```cpp MyClass(MyClass obj) { a = obj.a; } ``` This would cause an infinite loop when attempting to create a copy because: 1. A new object is created when passing by value. 2. Creating a new object requires calling the constructor (which in this case is the copy constructor). 3. Calling the copy constructor requires passing the object by value, leading to step 1. By using a reference parameter in the copy constructor, this infinite loop is prevented, as no new object is created when passing a reference.