Understanding Parameterized Constructor in C++: Working and Examples

Think of building a custom computer. Instead of getting a one-size-fits-all model, you select the features—RAM, storage, and processor—that match your personal preferences. This is precisely what a parameterized constructor does in C++: it lets you define specific values for each object right when it’s created, tailoring it to your exact needs.

Do you know why it is important to initialize objects in a programming language? It saves your time and eliminates repetitive setup. It enhances the efficiency of your code by allowing you to set unique values for each object during its creation. In this blog, we’ll explore how to use a parameterized constructor in C++, along with its syntax. Let’s dive in!

What Is a Constructor in C++?

A constructor in C++ is a special method in a class that is automatically called when you create an object of that class. Its function is to set things up for the object, such as giving it default values or initializing the resources it needs to work correctly.

In layman's terms, the constructor in C++ is like the setup instructions you have to follow when assembling a piece of furniture or a gadget.

Also Read: Constructors in C++

Now that you have a basic understanding of a constructor let’s dive deeper into parameterized constructors in C++.

What Is a Parameterized Constructor in C++?

A parameterized constructor in C++ is a type of constructor that takes arguments (parameters). Giving arguments allows you to initialize an object with specific values when you create it instead of always providing the object's default values.

Here are the reasons you must use a parameterized constructor in C++.

• Customization

The parameterized constructor allows an object to start with its own unique set of values. For example, you can create one Car object with a top speed of 180 and another with a top speed of 240.

• Efficiency

You have to manually set the values after creating the object if you don’t use parameterized constructors.

• Cleaner code

You can reduce repetitive code by using the parameterized constructor. Instead of writing separate statements to set each data member, you can initialize them all in the constructor.

For illustration, consider the following example.

• Imagine a class Car where every car has a brand and a top speed. A parameterized constructor allows you to specify the brand and top speed for each car.
• The Car class has a parameterized constructor Car(string b, int s), which takes two arguments: a brand and a top speed.
• When you create objects like car1 and car2, you provide specific values for their brand and topSpeed.
• Each object gets initialized with its own unique values.

Code snippet:

#include <iostream>
using namespace std;

class Car {
    string brand;
    int topSpeed;

public:
    // Parameterized constructor
    Car(string b, int s) {
        brand = b;
        topSpeed = s;
    }

    void displayInfo() {
        cout << "Brand: " << brand << ", Top Speed: " << topSpeed << " km/h" << endl;
    }
};

int main() {
    Car car1("Toyota", 180); // Pass values to the constructor
    Car car2("BMW", 240);    // Different values for another object

    car1.displayInfo();
    car2.displayInfo();

    return 0;
}

Output:

Brand: Toyota, Top Speed: 180 km/h
Brand: BMW, Top Speed: 240 km/h

If you understand the concept of constructor overloading in C++, let’s explore how you can write a parameterized constructor in C++.

Syntax of Parameterized Constructor in C++

You can use a parameterized constructor in C++ in two ways: inside the class and outside the class. In inside the class method, you declare and define the constructor inside the class. The implementation is directly within the class body. This approach keeps everything compact and is useful for small classes.

Here‘s the syntax of inside the class approach.

Syntax:

class ClassName {
public:
    // Declaration and definition inside the class
    ClassName(DataType parameter1, DataType parameter2) {
        // Initialization logic here
    }
};

Code Example:

In the following example, the parameterized constructor is written directly in the Person class body.

class Person {
    string name;
    int age;

public:
    // Parameterized constructor defined inside the class
    Person(string n, int a) {
        name = n;
        age = a;
    }

    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

The outside-the-class approach declares the constructor in the class and defines it outside. This approach is suitable for larger classes or when you want to organize your code for better readability.

Syntax:

class ClassName {
public:
    // Declaration of parameterized constructor
    ClassName(DataType parameter1, DataType parameter2);
};

// Definition of parameterized constructor outside the class
ClassName::ClassName(DataType parameter1, DataType parameter2) {
    // Initialization logic here
}

Code syntax:

class Person {
    string name;
    int age;

public:
    // Declaration of parameterized constructor
    Person(string n, int a);

    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

// Definition of parameterized constructor outside the class
Person::Person(string n, int a) {
    name = n;
    age = a;
}

Also Read: 10 Best Computer Programming Courses to Get a Job in 2025

After a basic understanding of syntax, let’s check out the working of a parameterized constructor in C++.

How Parameterized Constructor in C++ Work?

Parameterized constructors allow you to pass arguments to set the initial state of an object. This flexibility will enable you to create objects with different properties without the need for repetitive manual initialization. By combining object creation and initialization in a single step, parameterized constructors improve code efficiency, readability, and maintainability.

Here’s a step-by-step explanation of how parameterized constructors work in C++. 

1. Declaration

You can declare a parameterized constructor in the class by specifying its name (same as the class name) followed by a parameter list. These parameters define the values that the constructor will accept during object creation.

Syntax:

class ClassName {
public:
    ClassName(DataType parameter1, DataType parameter2); // Constructor declaration
};

Code snippet:

class Person {
public:
    Person(string name, int age); // Declares a parameterized constructor
};

2. Definition

The parameterized constructor can be defined either inside or outside the class. If defined outside, the ClassName::ConstructorName syntax associates the definition with the class.

Syntax:

Inside the class:

class ClassName {
public:
    ClassName(DataType parameter1, DataType parameter2) {
        // Initialization logic here
    }
};

Outside the class:

ClassName::ClassName(DataType parameter1, DataType parameter2) {
    // Initialization logic here
}

Code snippet:

class Person {
    string name;
    int age;

public:
    Person(string n, int a); // Constructor declaration

    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

// Constructor definition outside the class
Person::Person(string n, int a) {
    name = n;
    age = a;
}

3. Object Creation

When you create an object of the class, you pass the required arguments to the constructor. The constructor automatically assigns these values to the object’s data members.

Syntax:

ClassName objectName(parameter1_value, parameter2_value);

Code snippet:

int main() {
    Person person1("Rahul", 25);  // Creates a Person object and initializes it
    person1.display();

    Person person2("Priya", 30);    // Another object with different values
    person2.display();

    return 0;
}

Output:

Name: Rahul, Age: 25
Name: Priya, Age: 30

4. Initialization

A parameterized constructor automates the initialization process by assigning the passed values to the object's data members. In this way, every object is correctly initialized as soon as it is created without needing additional function calls.

Code snippet:

Without parameterized constructor:

person1.setName("Raj");
person1.setAge(25);

With parameterized constructor:

Person person1("Raj", 25);

Also Read: What are the Advantages of Object-Oriented Programming?

In the following section, you can explore different ways of using a parameterized constructor in C++.

What is the Use of Parameterized Constructor in C++?

Parameterized constructors make your programs more robust, efficient, and easier to maintain, especially as the complexity rises. Here’s how you can make your code more efficient and flexible using a parameterized constructor in C++.

1. Constructor Overloading

Parameterized constructors work alongside default constructors and other overloaded constructors, providing different ways to initialize objects based on the context. This flexibility enables you to define constructors with varying parameters to suit different use cases.

Code snippet:

class Car {
public:
    Car() { cout << "Default Car\n"; }            // Default constructor
    Car(string brand, int speed) {               // Parameterized constructor
        cout << brand << " with speed " << speed << " created.\n";
    }
};

Car car1;                     // Calls the default constructor
Car car2("Toyota", 180);      // Calls the parameterized constructor

2. Assigning Different Values to Objects

Parameterized constructors allow each object to start with unique attributes, making it possible to create multiple objects with distinct values concisely.

Code snippet:

class Car {
    string brand;
    int speed;

public:
    Car(string b, int s) {  // Parameterized constructor
        brand = b;
        speed = s;
    }

    void display() {
        cout << "Brand: " << brand << ", Speed: " << speed << " km/h\n";
    }
};

Car car1("Toyota", 180);
Car car2("BMW", 240);

car1.display();
car2.display();

3. Ensuring mandatory initialization of attributes 

Using a parameterized constructor in C++, you can enforce the initialization of essential attributes by requiring specific arguments during object creation. This avoids uninitialized objects, reducing potential runtime errors.

Code snippet:

class Person {
    string name;
    int age;

public:
    Person(string n, int a) {  // Mandatory parameters
        name = n;
        age = a;
    }

    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

Person person("Alice", 25);  // Ensures name and age are always set
person.display();

4. Supporting polymorphic behavior

Parameterized constructors, used along with inheritance, can contribute to polymorphism by allowing base and derived classes to initialize objects with specific attributes dynamically.

Code snippet:

class Vehicle {
protected:
    int speed;

public:
    Vehicle(int s) : speed(s) {}
    virtual void display() { cout << "Speed: " << speed << " km/h\n"; }
};

class Car : public Vehicle {
    string brand;

public:
    Car(string b, int s) : Vehicle(s), brand(b) {}
    void display() override {
        cout << "Brand: " << brand << ", Speed: " << speed << " km/h\n";
    }
};

Vehicle* v = new Car("Tesla", 200);
v->display();  // Polymorphic behavior

Join upGrad’s free Java Object-Oriented Programming to explore high-paying jobs in emerging technologies.

Now that you understand how to use parameterized constructors in C++, let's explore some C++ constructor examples.

Examples of Parameterized Constructor in C++

Understanding parameterized constructors in C++ is easier when you see practical examples of how they are used. Here are some C++ constructor examples.

1. Car information with speed

Objective: 

To create a Car class that stores and displays the car brand and speed using a parameterized constructor.

Code snippet:

#include <iostream>
using namespace std;

class Car {
    string brand;
    int speed;

public:
    // Parameterized constructor
    Car(string b, int s) {
        brand = b;
        speed = s;
    }

    void display() {
        cout << "Car Brand: " << brand << ", Speed: " << speed << " km/h" << endl;
    }
};

int main() {
    Car car1("Maruti Suzuki", 150);  // Initializing with parameters
    car1.display();

    return 0;
}

Explanation:

The Car class has a constructor that takes the car’s brand and speed as arguments. When the object car1 is created, the constructor sets its values to "Maruti Suzuki" and 150.

Flow:

• The Car class is defined with a parameterized constructor that accepts brand and speed.
• When car1 is created in main(), the constructor is invoked with the parameters "Maruti Suzuki" and 150.
• The display() method is called to print the car's information to the console.

Output:

Car Brand: Maruti Suzuki, Speed: 150 km/h

2. Initializing student information

To create a class that stores and displays the information of a student using a parameterized constructor.

Code Snippet:

#include <iostream>
using namespace std;

class Student {
    string name;
    int rollNo;

public:
    // Parameterized constructor
    Student(string n, int r) {
        name = n;
        rollNo = r;
    }

    void display() {
        cout << "Student Name: " << name << ", Roll No: " << rollNo << endl;
    }
};

int main() {
    Student student1("Rahul Kumar", 101);  // Initializing with parameters
    student1.display();

    return 0;
}

Explanation:

The Student class has a parameterized constructor that accepts two parameters—name and rollNo. The constructor initializes these attributes when the object is created.

Flow:

• The Student class is defined with a parameterized constructor.
• The constructor initializes the data member's name and rollNo using the arguments passed when the object is created.
• In the main() function, an object student1 is created and initialized with "Rahul Kumar" and 101.
• The display() method is called on student1 to print the student's details.

Output:

Student Name: Rahul Kumar, Roll No: 101

3. Calculating the area of a rectangle 

Objective:

Calculate and display the area of a rectangle using a parameterized constructor that accepts the length and breadth.

Code snippet:

#include <iostream>
using namespace std;

class Rectangle {
    int length, breadth;

public:
    // Parameterized constructor
    Rectangle(int l, int b) {
        length = l;
        breadth = b;
    }

    void area() {
        cout << "Area of Rectangle: " << length * breadth << " square units" << endl;
    }
};

int main() {
    Rectangle rect1(10, 5);  // Initializing with length=10 and breadth=5
    rect1.area();

    return 0;
}

Explanation:

The Rectangle class has a constructor that takes the length and breadth as parameters. The area() function calculates the triangle’s area based on these values.

Flow:

• The Rectangle class is defined with a parameterized constructor that initializes the length and breadth attributes.
• The rect1 object is created in main() with values 10 and 5 for length and breadth, respectively.
• The area() method is called on rect1 to compute and display the area of the rectangle.

Output:

Area of Rectangle: 50 square units

4. Employee salary and department

Create an Employee class that stores and displays the name, salary, and department using a parameterized constructor.

Code snippet:

#include <iostream>
using namespace std;

class Employee {
    string name;
    float salary;
    string department;

public:
    // Parameterized constructor
    Employee(string n, float s, string d) {
        name = n;
        salary = s;
        department = d;
    }

    void display() {
        cout << "Employee Name: " << name << ", Salary: " << salary << ", Department: " << department << endl;
    }
};

int main() {
    Employee emp1("Amit Sharma", 50000.50, "IT");  // Initializing with parameters
    emp1.display();

    return 0;
}

Explanation:

The Employee class uses a parameterized constructor to initialize the employee’s name, salary, and department upon creation. The display() function outputs this information.

Flow:

• The Employee class is defined with a parameterized constructor that accepts the employee's name, salary, and department.
• The emp1 object is created in main() with values "Amit Sharma", 50000.50, and "IT".
• Emp1 calls the display() method to print the employee's name, salary, and department.

Output:

Employee Name: Amit Sharma, Salary: 50000.5, Department: IT

Also Read: What is Programming Language? Syntax, Top Languages, Example

After going through examples, let’s check how the default constructor differs from parameterized construction in C++.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Differences Between Default Constructor and Parameterized Constructor

There are two primary types of constructors in C++: default constructors and parameterized constructors. Both are essential for object initialization, but they differ in how they assign values to the object's attributes and their definition.

A default constructor does not take any parameters and provides default values for the object’s attributes. The compiler automatically generates a default constructor if no constructor is explicitly defined. On the other hand, a parameterized constructor takes one or more parameters and allows the initialization of an object with specific values at the time of its creation.

Do you know how a default constructor and a parameterized constructor differ from each other? Find out in the following table.

Also Read: Difference Between Overloading and Overriding

Now that you understand a parameterized constructor in C++, let's explore how to prepare for a career in programming.

How Can upGrad Help You Ace Your Programming Career?

The global job market is witnessing a surge in demand for skilled programmers. In 2024, approximately 40% of recruiters are looking for candidates proficient in programming languages such as Python, Java, and JavaScript.

upGrad’s courses focus on high-paying languages like Java and Python, positioning you for lucrative roles in the industry. These industry-oriented courses ensure that you acquire both theoretical knowledge and practical experience.

Here are some courses offered by upGrad in programming languages.

• Core Java Basics
• Java Object-Oriented programming
• JavaScript Basics from Scratch
• Learn Basic Python Programming
• Programming with Python: Introduction for Beginners

Do you need help deciding which course to choose for your career as a C++ programmer? Contact upGrad for personalized counseling and valuable insights.

Discover our free software development courses designed to enhance your skills and accelerate your career growth in the tech industry.

Explore Our Software Development Free Courses

Dive into our popular software engineering courses and gain the expertise needed to excel in the ever-evolving tech landscape.

Explore our Popular Software Engineering Courses

References:

https://www.statista.com/statistics/1296727/programming-languages-demanded-by-recruiters/