What is a copy constructor in C++?

On page 6 of Scott Meyers's Effective C++, the term 'copy constructor' is defined. I've been using Schiltdt's book as my reference and I can find no mention o开发者_StackOverflowf copy constructors. I get the idea but is this a standard part of c++? Will such constructors get called when a pass a class by value?

Yes, copy constructors are certainly an essential part of standard C++. Read more about them (and other constructors) here (C++ FAQ).

If you have a C++ book that doesn't teach about copy constructors, throw it away. It's a bad book.

A copy constructor has the following form:

class example 
{
    example(const example&) 
    {
        // this is the copy constructor
    }
}

The following example shows where it is called.

void foo(example x);

int main(void)
{
    example x1; //normal ctor
    example x2 = x1; // copy ctor
    example x3(x2); // copy ctor

    foo(x1); // calls the copy ctor to copy the argument for foo

}

See Copy constructor on Wikipedia.

The basic idea is copy constructors instantiate new instances by copying existing ones:

class Foo {
  public:
    Foo();                // default constructor
    Foo(const Foo& foo);  // copy constructor

  // ...
};

Given an instance foo, invoke the copy constructor with

Foo bar(foo);

or

Foo bar = foo;

The Standard Template Library's containers require objects to be copyable and assignable, so if you want to use std::vector<YourClass>, be sure to have define an appropriate copy constructor and operator= if the compiler-generated defaults don't make sense.

Copy constructor will be called in then following scenarios:

• When creating new objects from an existing object.

  MyClass Obj1;
  MyClass Obj2 = Obj1; // Here assigning Obj1 to newly created Obj2
  

  or

  MyClass Obj1;
  MyClass Obj2(Obj1);
  

• When passing class object by value.

  void NewClass::TestFunction( MyClass inputObject_i )
  {
    // Function body
  }
  

  Above MyClass object passed by value. So copy constructor of MyClass will call. Pass by reference to avoid copy constructor calling.

• When returning objects by value

  MyClass NewClass::Get()
  {
    return ObjMyClass;
  }
  

  Above MyClass is returned by value, So copy constructor of MyClass will call. Pass by reference to avoid copy constructor calling.

The C++ FAQ link posted by Eli is nice and gbacon's post is correct.

To explicitly answer the second part of your question: yes, when you pass an object instance by value the copy constructor will be used to create the local instance of the object in the scope of the function call. Every object has a "default copy constructor" (gbacon alludes to this as the "compiler generated default") which simply copies each object member - this may not be what you want if your object instances contain pointers or references, for example.

Regarding good books for (re)learning C++ - I first learned it almost two decades ago and it has changed a good deal since then - I recommend Bruce Eckel's "Thinking in C++" versions 1 and 2, freely available here (in both PDF and HTML form):

http://www.ibiblio.org/pub/docs/books/eckel/

Copy Constructor is an essential part of C++. Even-though any C++ compiler provides default copy constructor if at all if we don't define it explicitly in the class, We write copy constructor for the class for the following two reasons.

1. If there is any dynamic memory allocation in the class.
2. If we use pointer variables inside the class. (otherwise it will be a shallow copy in which 2 objects will point to the same memory location.)

To make a deep copy, you must write a copy constructor and overload the assignment operator, otherwise the copy will point to the original, with disastrous consequences.

The copy constructor syntax would be written as below:

class Sample{

public:
   Sample (const Sample &sample);

};

int main()
{

   Sample s1;
   Sample s2 = s1;   // Will invoke Copy Constructor.
   Sample s3(s1);     //This will also invoke copy constructor.

   return 0;
}

A copy constructor is a constructor which does deep copy. You should write your own copy constructor when there is a pointer type variable inside the class. Compiler will insert copy constructor automatically when there is no explicit copy constructor written inside the code. The type of a copy constructor parameter should always be reference type, this to avoid infinite recursion due to the pass by value type.

below program explains the use of copy constructor

#include <iostream>
#pragma warning(disable : 4996)
using namespace std;
class SampleTest {
private:
    char* name;
    int age;
public:   
    SampleTest(char *name1, int age) {
        int l = strlen(name1);
        name = new char[l + 1];
        strcpy(this->name, name1);
        this->age = age;
    }
        SampleTest(const SampleTest& s) { //copy constructor 
            int l = strlen(s.name);
            name = new char[l + 1];
            strcpy(this->name, s.name);
            this->age = s.age;
        }
    void displayDetails() {
        cout << "Name is " << this->name << endl;
        cout << "Age is " << this->age << endl;
    }
    void changeName(char* newName) {
        int l = strlen(newName);
        name = new char[l + 1];
        strcpy(this->name, newName);
    }
};
int main() {
    SampleTest s("Test", 10);
    s.displayDetails();
    SampleTest s1(s);
    cout << "From copy constructor" << endl;
    s1.displayDetails();
    s1.changeName("Test1");
    cout << "after changing name s1:";
    s1.displayDetails();
    s.displayDetails();
    cin.get();
    return 0;
}