{"title":"Constructors","description":null,"content":"A constructor is a special member function that runs automatically when an object is created. It exists so that an instance starts life in a valid, fully-initialized state instead of holding whatever bits happened to be in memory. This lesson covers default constructors, parameterized constructors, overloading them, delegating one constructor to another, and the `= default` and `= delete` controls that decide which constructors the compiler generates.\n\n---\n\n# Why Constructors Exist\n\nA class that only exposes data members and relies on the caller to set them is fragile. If a caller forgets one field, the object is half-initialized. If two callers disagree on what \"valid\" looks like, every site that touches the type has to repeat the same logic.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n};\n\nint main() {\n Product mouse;\n mouse.name = \"Wireless Mouse\";\n mouse.price = 24.99;\n // forgot to set stock; whatever was in memory is what we get\n std::cout << mouse.name << \" stock=\" << mouse.stock << std::endl;\n return 0;\n}\n```\n\n\nThe `stock` field was never set, so reading it is undefined behavior. The same problem comes back every time someone creates a `Product`. A constructor fixes this by making \"create an instance\" and \"set its fields to valid values\" the same step.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n Product(const std::string& productName, double productPrice, int productStock) {\n name = productName;\n price = productPrice;\n stock = productStock;\n }\n};\n\nint main() {\n Product mouse(\"Wireless Mouse\", 24.99, 50);\n std::cout << mouse.name << \" $\" << mouse.price << \" stock=\" << mouse.stock << std::endl;\n return 0;\n}\n```\n\n\nThe constructor's job is to take whatever arguments the caller supplies and put the object into a known good state. After the constructor finishes, the object is ready to use. Nothing can create a `Product` without going through some constructor, which means the type controls its own invariants.\n\n---\n\n# Initialization vs Assignment\n\nInside a constructor body, statements like `name = productName;` look like initialization but they are actually assignment. The data members were already constructed before the body started running, using their default constructors. The body then overwrites them.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name; // default-constructed to \"\" first\n double price; // built-in type, holds garbage initially\n int stock; // built-in type, holds garbage initially\n\n Product(const std::string& n, double p, int s) {\n name = n; // assignment to an already-constructed string\n price = p; // assignment to an already-existing double\n stock = s;\n }\n};\n```\n\n\nFor built-in types like `int` and `double`, the cost of one assignment is the same as one initialization, so this works. For class-type members like `std::string`, the body-assignment pattern does extra work: the string is first default-constructed (allocating an empty state), then assigned to (potentially freeing the empty state and allocating again).\n\n\n> **INFO**\n>\n> **Cost:** Body-assignment of class-type members does two operations: default-construct, then assign. Member initializer lists (covered in the C++ Advanced section) construct each member with its final value in one step, skipping the default-construct.\n\n\nThis lesson sticks to body-assignment because it is the most common pattern beginners read in production code. A later chapter shows the initializer list syntax (`Product(...) : name(n), price(p), stock(s) {}`) which is the preferred form once you are comfortable with it.\n\n---\n\n# The Default Constructor\n\nA constructor that takes no arguments is called a **default constructor**. If a class has one, you can create an instance without supplying any values.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n Product() {\n name = \"Unnamed\";\n price = 0.0;\n stock = 0;\n }\n};\n\nint main() {\n Product placeholder;\n std::cout << placeholder.name << \" $\" << placeholder.price\n << \" stock=\" << placeholder.stock << std::endl;\n return 0;\n}\n```\n\n\nThe line `Product placeholder;` calls the default constructor. No parentheses, no arguments. After it returns, every field has a meaningful value.\n\nThere is a common pitfall here. If you wanted to call the default constructor and wrote `Product placeholder();`, you would not get an object. You would declare a function named `placeholder` that takes no arguments and returns a `Product`. This is called the **most vexing parse**. The fix is to drop the parentheses or use braces:\n\n\n```cpp\nProduct a; // calls the default constructor\nProduct b{}; // also calls the default constructor (C++11)\nProduct c(); // declares a function. Not what you wanted.\n```\n\n\n### Compiler-Generated Default Constructor\n\nIf you write no constructors at all, the compiler generates one for you. This implicit default constructor does the minimum: it default-constructs each data member. For class-type members like `std::string`, that means calling their default constructor. For built-in types like `int` and `double`, it does nothing, leaving them uninitialized.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n // no constructor written; compiler generates one\n};\n\nint main() {\n Product p;\n std::cout << \"name='\" << p.name << \"', price=\" << p.price\n << \", stock=\" << p.stock << std::endl;\n return 0;\n}\n```\n\n\nThe `name` came out empty because `std::string` defaults to empty. The `price` and `stock` show garbage because the compiler-generated default constructor never touched them. Many bugs in beginner C++ code come from assuming the compiler will zero things out. It will not.\n\nThere is a simple way to make the compiler-generated constructor produce zeroed numerics: give each data member an **in-class initializer**:\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name = \"Unnamed\";\n double price = 0.0;\n int stock = 0;\n};\n\nint main() {\n Product p;\n std::cout << p.name << \" $\" << p.price << \" stock=\" << p.stock << std::endl;\n return 0;\n}\n```\n\n\nIn-class initializers act as the default value whenever a constructor does not set the field some other way. With these in place, the compiler-generated default constructor produces a clean, fully-initialized object every time.\n\n### When the Compiler Removes the Default Constructor\n\nThe implicit default constructor is generated only when the class does not define any other constructor. As soon as you write any constructor of your own, the implicit default disappears.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n Product(const std::string& n, double p, int s) {\n name = n;\n price = p;\n stock = s;\n }\n};\n\nint main() {\n Product mouse(\"Wireless Mouse\", 24.99, 50); // fine\n Product placeholder; // compile error\n return 0;\n}\n```\n\n\n**Compiler error (g++):**\n\n\n```shell\nerror: no matching function for call to 'Product::Product()'\nnote: candidate: 'Product::Product(const std::string&, double, int)'\nnote: candidate expects 3 arguments, 0 provided\n```\n\n\nThe moment you wrote `Product(const std::string&, double, int)`, the compiler stopped generating a free `Product()`. The reasoning is that if you cared enough to write a constructor, you are also responsible for deciding whether a no-argument version makes sense. If you want both, you have to write the default one yourself or ask the compiler to put it back (covered later in this lesson with `= default`).\n\n---\n\n# Parameterized Constructors\n\nA constructor that takes one or more arguments lets the caller supply data at construction time. You have already seen this pattern, but it is worth pinning down a few details.\n\n\n```cpp\n#include \n#include \n\nclass Customer {\npublic:\n std::string name;\n std::string email;\n int loyaltyPoints;\n\n Customer(const std::string& customerName, const std::string& customerEmail, int points) {\n name = customerName;\n email = customerEmail;\n loyaltyPoints = points;\n }\n};\n\nint main() {\n Customer alice(\"Alice Tan\", \"alice@example.com\", 240);\n Customer bob(\"Bob Lee\", \"bob@example.com\", 50);\n\n std::cout << alice.name << \" (\" << alice.loyaltyPoints << \" pts)\" << std::endl;\n std::cout << bob.name << \" (\" << bob.loyaltyPoints << \" pts)\" << std::endl;\n return 0;\n}\n```\n\n\nStrings are passed by `const` reference because copying a `std::string` allocates memory, and the constructor only needs to read from the argument. Integers are passed by value because copying a 4-byte int is essentially free.\n\nThere are three syntaxes for calling a parameterized constructor:\n\n\n```cpp\nCustomer a(\"Alice\", \"alice@example.com\", 240); // parentheses\nCustomer b{\"Bob\", \"bob@example.com\", 50}; // braces (C++11)\nCustomer c = {\"Cara\", \"cara@example.com\", 75}; // copy-list-initialization\n```\n\n\nAll three call the same constructor. Braces are the most modern choice and avoid the most vexing parse, so many style guides prefer them. The parentheses form is what you see in older code and in most textbooks.\n\n### Default Arguments in Constructors\n\nA constructor can declare default values for its parameters, just like any other function. This lets the same constructor act as a default constructor when called with fewer arguments.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n Product(const std::string& n = \"Unnamed\", double p = 0.0, int s = 0) {\n name = n;\n price = p;\n stock = s;\n }\n};\n\nint main() {\n Product blank; // uses all three defaults\n Product cable(\"USB Cable\"); // name set, price=0.0, stock=0\n Product mouse(\"Wireless Mouse\", 24.99, 50); // all three supplied\n\n std::cout << blank.name << \" $\" << blank.price << \" x \" << blank.stock << std::endl;\n std::cout << cable.name << \" $\" << cable.price << \" x \" << cable.stock << std::endl;\n std::cout << mouse.name << \" $\" << mouse.price << \" x \" << mouse.stock << std::endl;\n return 0;\n}\n```\n\n\nOne constructor with default arguments is often enough to cover three or four usage patterns. The same rules as for any other function apply: defaults must appear on the trailing parameters, you cannot have a gap in the middle, and the defaults are picked left-to-right.\n\n---\n\n# Constructor Overloading\n\nA class can have more than one constructor as long as their parameter lists are different. The compiler picks which constructor to call based on the types and number of arguments at the call site. This is **constructor overloading**.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n // 1. default constructor\n Product() {\n name = \"Unnamed\";\n price = 0.0;\n stock = 0;\n }\n\n // 2. name only\n Product(const std::string& productName) {\n name = productName;\n price = 0.0;\n stock = 0;\n }\n\n // 3. name and price\n Product(const std::string& productName, double productPrice) {\n name = productName;\n price = productPrice;\n stock = 0;\n }\n\n // 4. name, price, and stock\n Product(const std::string& productName, double productPrice, int productStock) {\n name = productName;\n price = productPrice;\n stock = productStock;\n }\n};\n\nint main() {\n Product a; // calls 1\n Product b(\"USB Cable\"); // calls 2\n Product c(\"HDMI Cable\", 12.99); // calls 3\n Product d(\"Wireless Mouse\", 24.99, 50); // calls 4\n\n std::cout << a.name << \" $\" << a.price << \" x \" << a.stock << std::endl;\n std::cout << b.name << \" $\" << b.price << \" x \" << b.stock << std::endl;\n std::cout << c.name << \" $\" << c.price << \" x \" << c.stock << std::endl;\n std::cout << d.name << \" $\" << d.price << \" x \" << d.stock << std::endl;\n return 0;\n}\n```\n\n\nFour constructors, each one a different way to build a `Product`. The compiler matches the arguments to whichever overload fits best. If two overloads match equally well, the call is ambiguous and the compiler refuses to compile it.\n\nA common ambiguity trap shows up when default arguments and overloading mix:\n\n**What's wrong with this code?**\n\n\n```cpp\nclass Order {\npublic:\n int itemCount;\n Order() {\n itemCount = 0;\n }\n Order(int count = 0) {\n itemCount = count;\n }\n};\n\nint main() {\n Order o; // which constructor?\n return 0;\n}\n```\n\n\n`Order()` and `Order(int count = 0)` are both callable with zero arguments, so the compiler cannot pick. Either remove the default value from the second constructor or remove the first constructor.\n\n**Fix:**\n\n\n```cpp\nclass Order {\npublic:\n int itemCount;\n Order(int count = 0) { // covers Order() and Order(5)\n itemCount = count;\n }\n};\n```\n\n\nOverloading is the right tool when each constructor does something genuinely different. Default arguments are the right tool when one constructor body covers all cases and just needs flexible inputs. Mixing them creates ambiguities.\n\n\n> **INFO**\n>\n> **Cost:** Constructor overload resolution happens at compile time, not runtime. Once compiled, calling an overloaded constructor is no slower than calling a single constructor. The cost is paid by you and the compiler, in code complexity and compile time, not by the program.\n\n\n---\n\n# Delegating Constructors\n\nWhen you have several overloaded constructors, the bodies often repeat the same logic. C++11 introduced **delegating constructors**, which let one constructor call another constructor of the same class to do the actual work. This removes the duplication.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n // primary constructor: does all the work\n Product(const std::string& productName, double productPrice, int productStock)\n : name(productName), price(productPrice), stock(productStock) {}\n\n // delegating: forwards to the primary with defaults\n Product() : Product(\"Unnamed\", 0.0, 0) {}\n\n // delegating: name only\n Product(const std::string& productName) : Product(productName, 0.0, 0) {}\n\n // delegating: name and price\n Product(const std::string& productName, double productPrice)\n : Product(productName, productPrice, 0) {}\n};\n\nint main() {\n Product a;\n Product b(\"USB Cable\");\n Product c(\"HDMI Cable\", 12.99);\n Product d(\"Wireless Mouse\", 24.99, 50);\n\n std::cout << a.name << \" $\" << a.price << \" x \" << a.stock << std::endl;\n std::cout << b.name << \" $\" << b.price << \" x \" << b.stock << std::endl;\n std::cout << c.name << \" $\" << c.price << \" x \" << c.stock << std::endl;\n std::cout << d.name << \" $\" << d.price << \" x \" << d.stock << std::endl;\n return 0;\n}\n```\n\n\nThe syntax is `OtherConstructor(args)` in the position where a member initializer list would normally go. The delegated-to constructor runs first, fully constructs the object, and then the delegating constructor's body runs (if it has one).\n\nA few rules worth knowing:\n\n\n| Rule | Meaning |\n|------|---------|\n| One delegation per constructor | A constructor can delegate to at most one other constructor |\n| No mixing with member init | A delegating constructor cannot also initialize members directly in the same list |\n| No infinite loops | If constructor A delegates to B and B delegates back to A, you get undefined behavior |\n| Delegated-to runs first | The target constructor completes fully before the delegator's body runs |\n\n\nDelegation is the standard way to share construction logic across overloads. Without it, every overload would duplicate the same body, and a change to validation or default values would mean editing every constructor by hand.\n\nThe `: name(productName), price(productPrice), stock(productStock) {}` syntax used in the primary constructor above is a **member initializer list**. It initializes each member directly with the given value, skipping the default-construct-then-assign sequence. We cover the full mechanics in a later chapter; for now, just notice that the primary constructor uses it because it pairs naturally with delegation.\n\n\n> **INFO**\n>\n> **Cost:** Delegating constructors do not add runtime cost. The delegated-to constructor runs once, the delegator's body runs once, and the compiler typically inlines the chain. The benefit is purely about avoiding duplicated code.\n\n\n---\n\n# `= default` and `= delete`\n\nC++11 gave you two keywords that let you control which constructors the compiler generates: `= default` asks for the implicit version explicitly, and `= delete` removes a constructor entirely.\n\n### `= default`: Bring Back the Implicit Constructor\n\nWhen you write a constructor, the compiler stops generating the default one. If you still want the implicit default constructor alongside your custom one, you can ask for it with `= default`:\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name = \"Unnamed\";\n double price = 0.0;\n int stock = 0;\n\n Product(const std::string& n, double p, int s) {\n name = n;\n price = p;\n stock = s;\n }\n\n Product() = default; // bring back the implicit default constructor\n};\n\nint main() {\n Product placeholder; // works because of = default\n Product mouse(\"Wireless Mouse\", 24.99, 50);\n\n std::cout << placeholder.name << \" $\" << placeholder.price << \" x \" << placeholder.stock << std::endl;\n std::cout << mouse.name << \" $\" << mouse.price << \" x \" << mouse.stock << std::endl;\n return 0;\n}\n```\n\n\nThe compiler-generated default constructor uses the in-class initializers, so `placeholder` ends up with `\"Unnamed\"`, `0.0`, and `0` without you writing any constructor body. This is cleaner than writing a manual default constructor that does the same thing.\n\n`= default` is also a signal to readers of your code. \"I thought about this, I want the standard default behavior, and I am making that choice explicit.\" A manually-written `Product() {}` looks identical at the call site, but `= default` tells the compiler to generate whatever the standard rules say, which is more robust if the class grows new members later.\n\n### `= delete`: Forbid a Constructor\n\nSometimes you want a class that genuinely cannot be created with no arguments, or cannot be created at all. `= delete` makes a constructor unavailable, and any code that tries to use it fails to compile.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n Product(const std::string& n, double p, int s) {\n name = n;\n price = p;\n stock = s;\n }\n\n Product() = delete; // cannot create a Product without arguments\n};\n\nint main() {\n Product mouse(\"Wireless Mouse\", 24.99, 50); // fine\n // Product placeholder; // compile error\n std::cout << mouse.name << \" $\" << mouse.price << std::endl;\n return 0;\n}\n```\n\n\nIf you uncomment the `Product placeholder;` line, the compiler refuses with a message like:\n\n\n```shell\nerror: use of deleted function 'Product::Product()'\nnote: declared here: Product() = delete;\n```\n\n\n`= delete` is useful when the type does not have a sensible no-argument state. A `Customer` with no name and no email is not really a customer, so deleting the default constructor forces every caller to provide real values.\n\nYou can delete any constructor, not just the default one. We will see this again in later lessons when we discuss preventing copies of unique resources, but the syntax is the same: `ConstructorSignature = delete;`.\n\n\n| Form | Meaning |\n|------|---------|\n| `Type() = default;` | \"Compiler, please generate the implicit version of this constructor\" |\n| `Type() = delete;` | \"Compiler, do not generate it, and reject any code that tries to call it\" |\n\n\n\n> **INFO**\n>\n> **Cost:** `= default` and `= delete` are compile-time controls. Neither one changes the runtime behavior of code that successfully compiles. Deleted constructors simply cause compile errors instead of generating code.\n\n\n---\n\n# Object Construction Sequence\n\nWhen you write `Product mouse(\"Wireless Mouse\", 24.99, 50);`, the compiler runs a sequence of steps. Knowing this sequence helps explain why certain rules exist.\n\n\n```mermaid\nflowchart TB\n A[1. Memory allocated
for the object]:::cyan --> B[2. Data members
constructed in
declaration order]:::orange\n B --> C[3. Constructor body
runs]:::green\n C --> D[4. Object ready
to use]:::teal\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\nEach step matters:\n\n1. **Memory allocation.** Storage for the whole object is reserved. For a local variable, that's on the stack. For a `new` expression, that's on the heap.\n2. **Data members are constructed in declaration order.** This is the order they appear inside the class, top to bottom. It is not the order they are listed in a member initializer list, and it is not the order arguments arrive in. If you list them in a different order in an initializer list, the compiler still constructs them in declaration order and may warn you.\n3. **The constructor body runs.** By the time the first line of the body executes, every member is already constructed. The body then assigns or modifies them.\n4. **The object is fully alive** and can be used by the rest of the program.\n\nThe same sequence runs in reverse when the object is destroyed: body runs first (in the destructor), then members are destroyed in reverse declaration order, then memory is freed. We will pick that up in the next lesson on destructors.\n\nA small example shows the declaration-order rule in action:\n\n\n```cpp\n#include \n#include \n\nclass Logged {\npublic:\n std::string label;\n\n Logged(const std::string& l) {\n label = l;\n std::cout << \"Constructed: \" << label << std::endl;\n }\n};\n\nclass Order {\npublic:\n Logged first{\"first member\"};\n Logged second{\"second member\"};\n Logged third{\"third member\"};\n\n Order() {\n std::cout << \"Order body running\" << std::endl;\n }\n};\n\nint main() {\n Order o;\n return 0;\n}\n```\n\n\nThe three `Logged` members are constructed top to bottom, and only then does the `Order` constructor's body run. If you reordered the members so `third` came before `second` in the class body, the output would change to reflect the new declaration order.\n\nThere is one more piece worth flagging now without a deep dive. A single-argument constructor like `Product(const std::string&)` can be triggered by accident when you pass a string where a `Product` is expected, because the compiler tries to convert. The `explicit` keyword turns off this implicit conversion. The \"Explicit Constructors\" chapter later in the section covers when to use it and what bugs it prevents.\n\n---\n\n# Summary\n\n- A constructor is a special member function that runs when an object is created and is responsible for putting its data members into a valid state.\n- Inside a constructor body, statements that look like initialization are actually assignment; members are constructed first (using their defaults), then the body runs. Member initializer lists, covered in a later chapter, construct members directly with final values.\n- The compiler generates a default constructor only when no other constructor is written. Writing any constructor of your own suppresses the implicit default, which is the most common source of \"no matching function\" errors.\n- Constructor overloading lets a class have multiple constructors with different parameter lists; default arguments let one constructor cover several call patterns. Mixing the two can create ambiguity, so pick one approach per class.\n- Delegating constructors (C++11) let one constructor call another in its initializer list, removing duplicated logic across overloads. Pick one primary constructor and have the others forward to it.\n- `= default` asks the compiler to generate the implicit version of a constructor, which is more robust than writing an empty body. `= delete` removes a constructor entirely so any call to it fails to compile.\n- During construction, memory is allocated first, then data members are constructed in declaration order (not initializer-list order), and finally the constructor body runs.\n- Single-argument constructors can trigger implicit conversions; the `explicit` keyword, covered later, turns this off when you do not want it.\n\nIn the next lesson, we'll look at **Destructors**, the mirror image of constructors that run when an object goes out of scope and are how C++ classes clean up resources.","pageType":"cpp"}

Constructors

Get Premium