Constructor overloading in C++ - Mini Project: Build & Apply

Constructor overloading

📖 Scenario: Imagine you are creating a simple program to manage information about books in a library. Each book can be created with different details depending on what information you have.

🎯 Goal: You will build a Book class with multiple constructors that allow creating book objects in different ways. This is called constructor overloading.

📋 What You'll Learn

Create a Book class with overloaded constructors

One constructor should take no arguments and set default values

One constructor should take the book title as a std::string

One constructor should take the book title and author as std::string

Create objects using each constructor

Print the book details to show the constructor used

💡 Why This Matters

🌍 Real World

Constructor overloading is useful when you want to create objects flexibly depending on how much information you have. For example, a library system might create book records with just a title or with full details.

💼 Career

Understanding constructor overloading is important for software developers working with object-oriented languages like C++. It helps write clean, flexible, and easy-to-use classes.

1

Create the Book class with default constructor

Write a Book class with a default constructor that sets title to "Unknown" and author to "Unknown". Declare title and author as std::string members.

C++

#include 
#include 

// Define Book class with default constructor
// Your code here

Hint

Remember to include std::string members and write a constructor with no parameters that sets default values.

2

Add constructor with title parameter

Add a constructor to the Book class that takes a std::string parameter called title and sets the title member to it. Set author to "Unknown" inside this constructor.

C++

#include 
#include 

class Book {
public:
    std::string title;
    std::string author;

    Book() {
        title = "Unknown";
        author = "Unknown";
    }

    // Add constructor with title parameter here
    // Your code here
};

Hint

Use this->title = title; to set the member variable inside the constructor.

3

Add constructor with title and author parameters

Add another constructor to the Book class that takes two std::string parameters: title and author. Set the class members title and author to these parameters.

C++

#include 
#include 

class Book {
public:
    std::string title;
    std::string author;

    Book() {
        title = "Unknown";
        author = "Unknown";
    }

    Book(std::string title) {
        this->title = title;
        author = "Unknown";
    }

    // Add constructor with title and author parameters here
    // Your code here
};

Hint

Use this-> to assign both title and author inside the constructor.

4

Create objects and print their details

In the main function, create three Book objects: book1 using the default constructor, book2 using the constructor with title "1984", and book3 using the constructor with title "The Hobbit" and author "J.R.R. Tolkien". Then print the details of each book in the format: Title: [title], Author: [author].

C++

#include 
#include 

class Book {
public:
    std::string title;
    std::string author;

    Book() {
        title = "Unknown";
        author = "Unknown";
    }

    Book(std::string title) {
        this->title = title;
        author = "Unknown";
    }

    Book(std::string title, std::string author) {
        this->title = title;
        this->author = author;
    }
};

int main() {
    // Create book1, book2, book3
    // Print their details
    // Your code here
}

Hint

Create the three Book objects using the correct constructors and print their details using std::cout.

Practice

1. What is constructor overloading in C++?

easy

A. Creating constructors only with no parameters

B. Having multiple constructors with different parameters in the same class

C. Using the same constructor multiple times in a program

D. Defining constructors outside the class only

Solution

1. Step 1: Understand constructor overloading concept

   Constructor overloading means having more than one constructor in a class, each with different parameters.

2. Step 2: Match definition with options

   Having multiple constructors with different parameters in the same class correctly describes this concept, while others describe unrelated ideas.

3. Final Answer:

   Having multiple constructors with different parameters in the same class -> Option B

4. Quick Check:

   Constructor overloading = multiple constructors with different parameters [OK]

Hint: Look for multiple constructors with different parameter lists [OK]

Common Mistakes:

• Confusing overloading with overriding
• Thinking constructors must have no parameters
• Believing constructors can only be defined outside the class

2. Which of the following is the correct syntax for constructor overloading in C++?

easy

A. class MyClass { MyClass(); MyClass(int x); };

B. class MyClass { void MyClass(); void MyClass(int x); };

C. class MyClass { int MyClass(); int MyClass(int x); };

D. class MyClass { MyClass() int x; MyClass(int x) int x; };

Solution

1. Step 1: Check constructor syntax

   Constructors have no return type and share the class name.

2. Step 2: Identify correct syntax

   class MyClass { MyClass(); MyClass(int x); }; shows constructors with no return type and different parameters, which is correct. Others wrongly use return types or invalid syntax.

3. Final Answer:

   class MyClass { MyClass(); MyClass(int x); }; -> Option A

4. Quick Check:

   Constructors have no return type [OK]

Hint: Remember constructors have no return type, just the class name [OK]

Common Mistakes:

• Adding return types to constructors
• Using void or int before constructor name
• Incorrect punctuation or missing semicolons

3. What will be the output of the following code?

class Box {
public:
  int length;
  Box() { length = 5; }
  Box(int l) { length = l; }
};

int main() {
  Box b1;
  Box b2(10);
  std::cout << b1.length << " " << b2.length;
  return 0;
}

medium

A. 5 5

B. 0 10

C. 5 10

D. 10 5

Solution

1. Step 1: Identify which constructor is called for each object

   b1 uses the default constructor setting length to 5; b2 uses the parameterized constructor setting length to 10.

2. Step 2: Determine output from std::cout

   Output prints b1.length (5) and b2.length (10) separated by space.

3. Final Answer:

   5 10 -> Option C

4. Quick Check:

   Default constructor sets 5, parameterized sets 10 [OK]

Hint: Match constructor parameters with object creation [OK]

Common Mistakes:

• Assuming uninitialized variables default to 0
• Mixing up which constructor is called
• Forgetting to print both values

4. Find the error in this constructor overloading example:

class Sample {
public:
  Sample() { }
  Sample() { }
};

medium

A. Two constructors have the same parameter list causing a redefinition error

B. Constructors must have return type

C. Constructors cannot be public

D. Class must have at least one data member

Solution

1. Step 1: Check constructor signatures

   Both constructors have no parameters, so they have identical signatures.

2. Step 2: Understand C++ rules on overloading

   Constructors must differ in parameter lists to overload; identical signatures cause redefinition error.

3. Final Answer:

   Two constructors have the same parameter list causing a redefinition error -> Option A

4. Quick Check:

   Constructor signatures must differ [OK]

Hint: Overloaded constructors must differ in parameters [OK]

Common Mistakes:

• Trying to overload with same parameter list
• Adding return types to constructors
• Thinking constructors can't be public

5. Given the class below, which constructor will be called when creating MyClass obj(3.14);?

class MyClass {
public:
  MyClass(int x) { std::cout << "Int constructor"; }
  MyClass(double x) { std::cout << "Double constructor"; }
  MyClass(float x) { std::cout << "Float constructor"; }
};

hard

A. Compilation error due to ambiguity

B. Int constructor

C. Float constructor

D. Double constructor

Solution

1. Step 1: Identify argument type in object creation

   3.14 is a double literal by default in C++.

2. Step 2: Match argument type to constructor

   The constructor with double parameter matches exactly, so it is called.

3. Final Answer:

   Double constructor -> Option D

4. Quick Check:

   Exact type match constructor is chosen [OK]

Hint: Literal 3.14 is double by default, so double constructor called [OK]

Common Mistakes:

• Assuming float constructor is called for 3.14
• Thinking int constructor is called due to truncation
• Believing ambiguity causes error here