Constructor overloading in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of overloaded constructors with default and parameterized calls

What is the output of this C++ program that uses constructor overloading?

C++

#include <iostream>
using namespace std;

class Box {
public:
    int length, width;
    Box() { length = 0; width = 0; cout << "Default constructor called\n"; }
    Box(int l) { length = l; width = 0; cout << "One-parameter constructor called\n"; }
    Box(int l, int w) { length = l; width = w; cout << "Two-parameter constructor called\n"; }
};

int main() {
    Box b1;
    Box b2(5);
    Box b3(3, 4);
    return 0;
}

A

Two-parameter constructor called
One-parameter constructor called
Default constructor called

B

Default constructor called
One-parameter constructor called
Two-parameter constructor called

C

One-parameter constructor called
Default constructor called
Two-parameter constructor called

D

Default constructor called
Two-parameter constructor called
One-parameter constructor called

💡 Hint

Look at which constructor matches each object creation.

The object b1 calls the default constructor with no parameters.
The object b2 calls the constructor with one integer parameter.
The object b3 calls the constructor with two integer parameters.
Each constructor prints a unique message.

❓ Predict Output

intermediate

Output when calling overloaded constructors with explicit casts

What will this C++ program print when creating objects with explicit casts?

C++

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;
    Point() { x = 0; y = 0; cout << "Default Point\n"; }
    Point(int a) { x = a; y = 0; cout << "One-arg Point\n"; }
    Point(int a, int b) { x = a; y = b; cout << "Two-arg Point\n"; }
};

int main() {
    Point p1 = Point();
    Point p2 = Point(10);
    Point p3 = Point(7, 8);
    return 0;
}

A

Default Point
One-arg Point
Two-arg Point

B

One-arg Point
Default Point
Two-arg Point

C

Two-arg Point
One-arg Point
Default Point

D

Default Point
Two-arg Point
One-arg Point

💡 Hint

Explicit cast calls the matching constructor.

Each object is created by calling the constructor that matches the arguments:
Point() calls default constructor.
Point(10) calls one-argument constructor.
Point(7, 8) calls two-argument constructor.

🔧 Debug

advanced

Identify the error in overloaded constructors with default arguments

What error does this C++ code produce?

C++

#include <iostream>
using namespace std;

class Sample {
public:
    int a, b;
    Sample(int x = 0, int y = 0) { a = x; b = y; cout << "Constructor 1\n"; }
    Sample(int x) { a = x; b = 10; cout << "Constructor 2\n"; }
};

int main() {
    Sample s1;
    Sample s2(5);
    return 0;
}

A Compilation error: redefinition of constructor

B Runtime error: segmentation fault

C

No error, prints:
Constructor 1
Constructor 2

D Compilation error: ambiguous call to constructor

💡 Hint

Check how default arguments affect constructor overloading.

The constructor Sample(int x = 0, int y = 0) can be called with zero or one argument.
The constructor Sample(int x) also takes one argument.
This causes ambiguity when calling Sample(5) because both constructors match.
The compiler cannot decide which one to use, so it raises an ambiguous call error.

📝 Syntax

advanced

Which constructor declaration is invalid in C++?

Which of the following constructor declarations will cause a syntax error in C++?

A MyClass(int x = 5, int y);

B MyClass(int x, int y = 10);

C MyClass();

D MyClass(const MyClass &obj);

💡 Hint

Default arguments must be trailing parameters.

In option A, the parameter with a default value int x = 5 comes before a parameter without a default value int y.
This is invalid in C++ because once a parameter has a default value, all parameters to its right must also have default values.
Options B, C, and D are valid constructor declarations.

🚀 Application

expert

Number of objects created and constructors called

Consider this C++ program. How many objects are created and how many constructor calls are made in total?

C++

#include <iostream>
using namespace std;

class Test {
public:
    Test() { cout << "Default\n"; }
    Test(int x) { cout << "Param\n"; }
};

int main() {
    Test t1;
    Test t2(10);
    Test t3 = t2;
    Test t4 = Test(5);
    return 0;
}

A 4 objects created, 4 constructor calls

B 3 objects created, 4 constructor calls

C 4 objects created, 5 constructor calls

D 3 objects created, 3 constructor calls

💡 Hint

Remember copy initialization calls copy constructor if defined, else default copy constructor is used.

Objects created: t1, t2, t3, t4 → 4 objects.
Constructor calls:
- t1 calls default constructor.
- t2 calls parameterized constructor.
- t3 is copy initialized from t2, calls copy constructor (compiler generated).
- t4 is initialized by temporary object Test(5) (parameterized constructor), then copy initialized to t4 (copy constructor).
Total constructor calls: 5 (default, param, copy, param, copy).