Constructor vs default constructor

Question

I'm an aspiring software engineer and full-time CS student. During the holiday break, I have been working on exercises to be better at my craft (C++). There are topics that I just need some clarity on. I'm working on a Target Heart Rate Calculator.

I have spent hours, days, trying to understand the concept of the constructor vs default constructor. I know that a constructor is required for every object created.

Before going any further, I want to test my code where it prompts the user to enter their first name and then return it. For once and for all, for the slow learners out there struggling including myself, can anyone please just explain this in Layman's terms with a visual explanation, please?

Below is my code. I'm receiving an error:

no matching function for call to 'HeartRates::HeartRates()'

main.cpp

int main() {

    HeartRates patient;

    cout << "First name: ";
    string firstName;
    cin >> firstName;
    patient.setFirstName(firstName);
    patient.getFirstName();

    return 0;

HeartRate.h

// create a class called HeartRates
class HeartRates {
    public:
    // constructor receiving data
    HeartRates(string personFirstName, string personLastName, int month, int day, int year) {
        firstName = personFirstName;
        lastName = personLastName;
        birthMonth = month;
        birthDay = day;
        birthYear = year;    
    }
    void setFirstName(string personFirstName) {
        firstName = personFirstName;
    }
    string getFirstName() {
        return firstName;
    }
    private:
    // attributes
    string firstName, lastName;
    int birthMonth, birthDay, birthYear;
};

---

Thank you, everyone! Sheesh! My book adds all these extra words that aren't necessary and makes the reading hard. All it had to say was:

If you want to create an object to receive information from a user, make sure your constructor has empty (). If you have data to input manually, pass that data through your constructor's parameters.

I hope this was the guise of your explanation. I love this community - thank you so much! You all have no idea about my back story - basically transitioning from a 15 years marketing/advertising career to becoming a software engineer. You all have been so welcoming and it confirms I made a great decision to switch.✊

Here is my updated code:

main.cpp

int main() {

    HeartRates patient;

    cout << "First name: ";
    string firstName;
    cin >> firstName;
    patient.setFirstName(firstName);
    cout << patient.getFirstName();

    return 0;
}

HeartRates.h

// create a class called HeartRates
class HeartRates {
    public:
    // constructor receiving data - THANKS STACKOVERFLOW COMMUNITY
    HeartRates() {
        firstName;
        lastName;
        birthMonth;
        birthDay;
        birthYear;    
    }
    void setFirstName(string personFirstName) {
        firstName = personFirstName;
    }
    string getFirstName() {
        return firstName;
    }
    private:
    // attributes
    string firstName, lastName;
    int birthMonth, birthDay, birthYear;
};

Answer 1

If you don't define any constructor, you get a constructor that takes no arguments.

As soon as you defined a constructor that has arguments, your no-args constructor retired to the North Pole.

So now you must write HeartRate("first", "last", 1, 1, 2001)

If you don't want to write that, delete the parameter list from your constructor and just set whatever you want for initial values.

Answer 2

Default constructor is any constructor that can be called with no arguments.

• MyClass() - default
• MyClass(int x) - not default
• MyClass(int x = 42) - default

If you don't define any constructor for your class, a compiler generates a default constructor automatically. It looks more or less like MyClass() {}.

HeartRates patient; tries to call a default constructor, since you didn't provide any arguments (that would be HeartRates patient(...);).

Answer 3

The difference between a default constructor and "normal" constructor is simpler than it may seem. As long as you don't specify the constructor in your class, when creating an object of an class, it always will call the default constructor, which, if you haven't implemented one, will do nothing but creating an object of that specific class with nothing initialized. If you now have implemented your own constructor, with some parameters, the only way to construct an object of that class will require you to call the implemented constructor. Your default constructor is then overwritten.

You can imagine it as a function you only defined. Something like this:

(the function foo is in this example as your constructor)

There is always a

void foo();

function

Whenever you call foo() it will call that specific function doing nothing. And the function foo() is alway given. If you now declare a second foo function like this:

void foo(std::string name)
{
   std::cout << "This is the name " << name << std::endl;
}

and you call your foo function, it will then call the new foo function that you have implemented.

Long story short, if you only have created a class with no customized constructor, you always have a default constructor that is been called when creating an object, but not really initializing something. Whenever you write your own customized constructor, it will overwrite the default constructor.