{"title":"Copy Constructor","description":null,"content":"A copy constructor is a special constructor that builds a new object as a copy of an existing object of the same type. C++ calls it implicitly in everyday situations: passing an object by value to a function, returning an object by value, and writing things like `Cart b = a;`. This chapter covers what the copy constructor looks like, when it runs, what the compiler-generated version actually does, and the cases where you have to write your own because the default does the wrong thing.\n\n---\n\n# What the Copy Constructor Looks Like\n\nA copy constructor is a constructor whose only parameter is a reference to another instance of the same class. The canonical signature is:\n\n\n```cpp\nClassName(const ClassName& other);\n```\n\n\nThe `const` and the `&` are both important. The reference avoids copying the source object (a copy constructor that copied its own parameter by value would call itself forever), and the `const` says the source isn't modified during the copy.\n\nHere it is on a simple e-commerce class:\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n\n Product(const std::string& n, double p) : name(n), price(p) {\n std::cout << \"Regular constructor for \" << name << std::endl;\n }\n\n Product(const Product& other) : name(other.name), price(other.price) {\n std::cout << \"Copy constructor: copying \" << other.name << std::endl;\n }\n};\n\nint main() {\n Product mouse(\"Wireless Mouse\", 24.99);\n Product backup = mouse;\n\n std::cout << backup.name << \" $\" << backup.price << std::endl;\n return 0;\n}\n```\n\n\nThe first line of output comes from building `mouse` with the regular constructor. The second line comes from `Product backup = mouse;`, which invokes the copy constructor with `mouse` as the `other` argument. Inside the copy constructor, `other.name` reads the source's name and the initializer list copies it into the new object's `name` field.\n\nThe `= ` in `Product backup = mouse;` does not call `operator=`. That syntax is **copy initialization**, and it runs the copy constructor, not the assignment operator. The distinction matters once you start writing your own assignment operators in a later lesson.\n\n---\n\n# When the Copy Constructor Runs\n\nThe compiler calls the copy constructor in three core situations:\n\n1. **Explicit copy initialization.** `Product b = a;` or `Product b(a);` build `b` from an existing `Product`.\n2. **Pass-by-value.** When a function parameter is declared as `Product p`, the caller's argument is copied into `p` using the copy constructor.\n3. **Return-by-value.** When a function returns a `Product` by value, the returned object is constructed in the caller's storage. In modern compilers this is often elided, but logically a copy is happening.\n\nThis example exercises all three:\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n\n Product(const std::string& n, double p) : name(n), price(p) {}\n\n Product(const Product& other) : name(other.name), price(other.price) {\n std::cout << \" [copy ctor for \" << name << \"]\" << std::endl;\n }\n};\n\nvoid printProduct(Product p) {\n std::cout << \"Inside printProduct: \" << p.name << \" $\" << p.price << std::endl;\n}\n\nProduct makeDiscounted(Product source, double percent) {\n Product result = source;\n result.price = result.price * (1.0 - percent / 100.0);\n return result;\n}\n\nint main() {\n Product mouse(\"Wireless Mouse\", 24.99);\n\n std::cout << \"Calling printProduct...\" << std::endl;\n printProduct(mouse);\n\n std::cout << \"Calling makeDiscounted...\" << std::endl;\n Product sale = makeDiscounted(mouse, 20.0);\n\n std::cout << \"Final sale price: $\" << sale.price << std::endl;\n return 0;\n}\n```\n\n\nWithout `-fno-elide-constructors`, modern compilers skip some of those copies via **copy elision**, an optimization that constructs the object directly in its final destination. The number of \"copy ctor\" lines printed can drop. Any time a `Product` flows in or out of a function by value, or `Product b = a;` is written, the copy constructor is in play conceptually.\n\nPass-by-value triggers the copy constructor every call. For a class with `std::string` or `std::vector` members, each copy allocates fresh heap memory. Pass non-trivial types by `const ClassName&` to avoid the copy for read-only access.\n\nThe reverse is also useful to know: when you write `Product b; b = a;`, that's two separate operations. The declaration `Product b;` runs the default constructor, and `b = a;` runs the copy assignment operator (a different special member that this course covers separately). Copy assignment is not the copy constructor.\n\n---\n\n# The Compiler-Generated Default Copy Constructor\n\nIf you don't write a copy constructor, the compiler generates one for you. The default version performs a **member-wise copy**: it goes through every data member in declaration order and copies it using that member's own copy behavior.\n\n\n```cpp\n#include \n#include \n\nclass Order {\npublic:\n int orderId;\n std::string customerEmail;\n double total;\n\n Order(int id, const std::string& email, double t)\n : orderId(id), customerEmail(email), total(t) {}\n // No copy constructor written. The compiler generates one.\n};\n\nint main() {\n Order original(101, \"alice@example.com\", 49.99);\n Order copy = original;\n\n copy.orderId = 102;\n copy.customerEmail = \"bob@example.com\";\n\n std::cout << \"original: \" << original.orderId << \" \" << original.customerEmail << std::endl;\n std::cout << \"copy: \" << copy.orderId << \" \" << copy.customerEmail << std::endl;\n return 0;\n}\n```\n\n\nThe generated copy constructor copied `orderId` as a plain int copy, `customerEmail` by calling `std::string`'s own copy constructor (which allocates a new buffer and copies the characters), and `total` as a plain double copy. After the copy, the two `Order` objects are independent: changing `copy.customerEmail` doesn't touch `original.customerEmail`, because each one owns its own string buffer.\n\nFor classes whose members are all primitives, standard library containers, or other well-behaved types, the default copy constructor is exactly what you want. You don't need to write one.\n\n\n```mermaid\nflowchart LR\n A[original Order]:::cyan --> A1[\"orderId: 101\"]:::orange\n A --> A2[\"customerEmail
alice@example.com\"]:::orange\n A --> A3[\"total: 49.99\"]:::orange\n\n B[copy Order]:::green --> B1[\"orderId: 101\"]:::teal\n B --> B2[\"customerEmail
alice@example.com\"]:::teal\n B --> B3[\"total: 49.99\"]:::teal\n\n A1 -.member-wise copy.-> B1\n A2 -.member-wise copy.-> B2\n A3 -.member-wise copy.-> B3\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram shows what member-wise copy does: every field on the right is built from the corresponding field on the left, using whatever copy behavior that field's type defines. For `std::string`, that includes allocating a separate buffer, which is why the two strings can be modified independently afterward.\n\n---\n\n# Shallow vs Deep Copy: The Pointer Problem\n\nThe default copy constructor works because each member knows how to copy itself correctly. `std::string`'s copy constructor allocates a new buffer; `std::vector`'s copy constructor allocates a new array. But the default copy constructor copies a raw pointer member by copying the **pointer value**, not the data it points to. Both objects end up pointing to the same memory.\n\nThat's a **shallow copy**: a bit-level copy of the pointer. The fix is a **deep copy**: allocate new memory and copy the contents.\n\nConsider a `Cart` class that holds a dynamically-allocated array of product names:\n\n\n```cpp\n#include \n#include \n\nclass Cart {\npublic:\n std::string customer;\n int capacity;\n std::string* items; // dynamically allocated array\n\n Cart(const std::string& name, int cap)\n : customer(name), capacity(cap), items(new std::string[cap]) {}\n\n ~Cart() {\n delete[] items;\n }\n\n void setItem(int index, const std::string& product) {\n items[index] = product;\n }\n\n void print() const {\n std::cout << customer << \"'s cart: \";\n for (int i = 0; i < capacity; ++i) {\n std::cout << items[i] << (i + 1 < capacity ? \", \" : \"\");\n }\n std::cout << std::endl;\n }\n};\n\nint main() {\n Cart a(\"Alice\", 2);\n a.setItem(0, \"Wireless Mouse\");\n a.setItem(1, \"USB Cable\");\n\n Cart b = a; // <-- shallow copy via default copy constructor\n b.setItem(0, \"HDMI Cable\");\n\n a.print();\n b.print();\n return 0;\n}\n```\n\n\n**Compiling this is fine, but running it is undefined behavior.** With the default copy constructor, the line `Cart b = a;` copies `a.items` (a pointer) into `b.items` directly, so both carts point at the same heap array. When `b.setItem(0, \"HDMI Cable\")` runs, it also overwrites `a`'s first item. Worse, when the program ends, both destructors run `delete[] items`, deleting the same memory twice. That's a classic **double-free**, and the program will typically crash or corrupt the heap.\n\nHere is what the memory looks like right after the shallow copy:\n\n\n```mermaid\nflowchart LR\n A[\"Cart a
customer: Alice
capacity: 2\"]:::cyan\n B[\"Cart b
customer: Alice
capacity: 2\"]:::green\n\n A -- items --> H[(\"heap array
Mouse, Cable\")]:::orange\n B -- items --> H\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nTwo carts, one heap array. Two destructors will eventually try to free that one array, and a write through one cart shows up in the other. Neither outcome is what anyone wants.\n\nA shallow copy is cheaper than a deep copy (no allocation, no element-wise copy), but for any class that owns dynamically allocated memory through a raw pointer, the shallow copy is wrong, not just slow. The cost comparison is irrelevant when one option is broken.\n\n---\n\n# Writing a Deep-Copy Constructor\n\nThe fix is to write a copy constructor that allocates new storage and copies each element. The signature stays `Cart(const Cart& other)`, the body changes:\n\n\n```cpp\n#include \n#include \n\nclass Cart {\npublic:\n std::string customer;\n int capacity;\n std::string* items;\n\n Cart(const std::string& name, int cap)\n : customer(name), capacity(cap), items(new std::string[cap]) {}\n\n // Deep-copy constructor\n Cart(const Cart& other)\n : customer(other.customer),\n capacity(other.capacity),\n items(new std::string[other.capacity]) {\n for (int i = 0; i < capacity; ++i) {\n items[i] = other.items[i];\n }\n std::cout << \"Deep-copied \" << customer << \"'s cart\" << std::endl;\n }\n\n ~Cart() {\n delete[] items;\n }\n\n void setItem(int index, const std::string& product) {\n items[index] = product;\n }\n\n void print() const {\n std::cout << customer << \"'s cart: \";\n for (int i = 0; i < capacity; ++i) {\n std::cout << items[i] << (i + 1 < capacity ? \", \" : \"\");\n }\n std::cout << std::endl;\n }\n};\n\nint main() {\n Cart a(\"Alice\", 2);\n a.setItem(0, \"Wireless Mouse\");\n a.setItem(1, \"USB Cable\");\n\n Cart b = a;\n b.setItem(0, \"HDMI Cable\");\n\n a.print();\n b.print();\n return 0;\n}\n```\n\n\nThe initializer list copies `customer` and `capacity` directly (those are safe), but `items` is initialized by allocating a brand-new array sized to match the source. The loop body then copies each element from `other.items` into the new array. After the copy, `a.items` and `b.items` point at different arrays, so writing through `b.items` no longer affects `a.items`, and each destructor frees its own array safely.\n\nThe same memory now looks like this:\n\n\n```mermaid\nflowchart LR\n A[\"Cart a
customer: Alice
capacity: 2\"]:::cyan\n B[\"Cart b
customer: Alice
capacity: 2\"]:::green\n\n A -- items --> H1[(\"array #1
Mouse, Cable\")]:::orange\n B -- items --> H2[(\"array #2
HDMI, Cable\")]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nTwo carts, two arrays, fully independent.\n\nOne subtle point: the member initializer list (`: customer(other.customer), capacity(other.capacity), items(...)`) initializes each field directly, in **declaration order**. That order matters because `items(new std::string[other.capacity])` uses `other.capacity`, not the new object's `capacity`. Either works in this case because they're equal, but writing `items(new std::string[capacity])` instead would rely on the order of initializer-list evaluation, which is a common source of bugs. The dedicated lesson on member initializer lists covers this in detail.\n\nDeep copy is O(n) where n is the size of the owned array, and it allocates from the heap. For large carts (hundreds of items with large strings), this cost is significant. If a class is being copied frequently, pass by `const` reference instead, or switch to a class that supports cheap moves.\n\n---\n\n# Disabling Copy with `= delete`\n\nSometimes copying an object doesn't make sense. A class that represents a unique resource (an open file, a database connection, a hardware handle) often shouldn't be copyable, because two copies of a \"connection\" would both try to manage the same underlying thing.\n\nC++11 added `= delete` for exactly this case. Mark the copy constructor as deleted, and the compiler will reject any attempt to copy:\n\n\n```cpp\n#include \n#include \n\nclass OrderSession {\npublic:\n int sessionId;\n std::string customer;\n\n OrderSession(int id, const std::string& name)\n : sessionId(id), customer(name) {}\n\n // No copying allowed\n OrderSession(const OrderSession& other) = delete;\n};\n\nint main() {\n OrderSession s1(42, \"Alice\");\n // OrderSession s2 = s1; // error: use of deleted function\n // OrderSession s3(s1); // error: use of deleted function\n\n std::cout << \"Session \" << s1.sessionId << \" for \" << s1.customer << std::endl;\n return 0;\n}\n```\n\n\nIf you uncomment either of the disabled lines, g++ refuses to compile and prints something like:\n\n\n```shell\nerror: use of deleted function 'OrderSession::OrderSession(const OrderSession&)'\n```\n\n\nThe error happens at compile time. Before `= delete`, the workaround was to declare the copy constructor private and not implement it, which produced a linker error or a confusing private-access error. `= delete` is clearer, works at compile time, and signals that the type is intentionally non-copyable.\n\nStandard library types like `std::unique_ptr`, `std::thread`, `std::mutex`, and `std::ifstream` all delete their copy constructors for the same reason: it doesn't make sense to copy a unique resource handle. Attempting to copy a `std::unique_ptr` produces a deleted-function error that points back to the standard library header.\n\n---\n\n# Rule of Three: A Quick Preview\n\nThe `Cart` example exposed a pattern. When a destructor frees a resource (`delete[] items`), the default copy constructor is almost certainly wrong, because it shares the pointer instead of duplicating the resource. A custom destructor, a custom copy constructor, and a custom copy assignment operator tend to come as a set. This is called the **Rule of Three**: if any one of those three is written, all three are typically needed.\n\nThe reasoning, briefly:\n\n\n| Special member | Why you write a custom one |\n|----------------|----------------------------|\n| Destructor | Class owns a resource the compiler doesn't know how to free |\n| Copy constructor | Default would shallow-copy that resource, sharing ownership |\n| Copy assignment | Default would shallow-copy that resource, leaking the old one |\n\n\nThe takeaway: don't write only one of these three for a resource-owning class. Either rely on the defaults (when the class composes well-behaved members like `std::string` and `std::vector`) or write all three.\n\nModern C++ also offers **move semantics**, which transfers ownership cheaply instead of copying. The Rule of Three then grows into the Rule of Five. For this lesson, the copy constructor by itself is enough; the rest of the family will fall into place later.","pageType":"cpp"}

Copy Constructor

Get Premium