We can directly assign value to any data member. why the use of constructor?

Question

I assign the value data member why need to use constructor??

I can not create a class constructor and I assign the value of my variable and my code run without creating a constructor?? so why use constructor

my question is We can directly assign value to any data member. see my code:

#include <iostream>
#include <conio.h>

class calculator {
  public:
    int n1=100;
    char grade='a';

    //  public:

    // calculator()
    // {
    //     grade='a';
    //     n1=100;

    // }

    void display()
    {
          std::cout << "first value:" <<grade<< std::endl;
          std::cout << "second value:" <<n1<< std::endl;
    }

};
int main()
{
    calculator cal;
    cal.display();
    return 0;
}

o/p is:

• first value:a
• second value:100

and when

#include <iostream>
#include <conio.h>

class calculator {


    int n1;
    char grade;

  private:

    calculator()
    {
         grade='A';
         n1=100;

    }

    void display()
    {
          std::cout << "first value:" <<grade<< std::endl;
          std::cout << "second value:" <<n1<< std::endl;
    }

};
int main()
{
    calculator cal;
    cal.display();
    return 0;
}

and suddenly i want to access private data members for example(employee salary) then how to access private data??

Answer 1

The job of the constructor is to initialize the object so that it is in a consistent and usable state. That means that it should ensure all members have sane initial values and should establish class invariants.

If you don't use a constructor and instead initialize members by hand every time you create an object, then you are first of all duplicating that work all over the place, and secondly you may forget to initialize something sometimes - which would leave the object in an inconsistent state.

Also, most members should not be public (since that leaves you without any control of how they are accessed/modified) and when they are private, a constructor (or in-class initialization) is the only way to initialize them.

Answer 2

The purpose of a constructor is to ensure objects are created in a consistent state. This helps prevent using them before they're ready. It's true you can just do this from the caller, but this violates the OOP concept of encapsulation in two ways: first, the caller must know enough about the class's implementation to know how to initialize its internal state properly; second, the caller must have access to that state to initialize it.

Answer 3

Unlike the C programming language, C++ is object oriented. One of the main concepts of object-oriented programming is encapsulation. This concept is about a couple of things. First, it is the idea that the data and methods that work on the data are "bundled" together as a unit (defined in a class in C++). The second idea is that the data or internal representation of the class be hidden to the users of the class as much as possible (this is referred to as information hiding). This allows the implementer of the class to change the internal workings of the class without impacting client code (other than necessitating perhaps a recompilation). Consequently, having attributes of a class (and thus of it objects that are instantiated) that are public is something to be avoided. This implies that client access to an object's internal state is only done indirectly through method calls. Thus, initialization of an object is done similarly via a constructor.

Answer 4

You can initialize an object in a consistent state without using a constructor and just initializing the fields themselves. When adding a new field, you'll just as likely forget to add initializations to a constructor as you are in the class itself.

In fact, it's better to initialize the values to some default value before even implementing a constructor.

The actual reasons constructors exist is because you can

a) write logic in them

struct A
{
  int field = -1;

  A()
  {
    if(rand() % 2 == 0)
      field = 10;
  }
};

b) receive the desired values from outside

struct B
{
  int field = -1;

  B(const int field)
  {
    this->field = field;
  }
}

c) overload them to have multiple ways of initializing values

struct C
{
  int field = -1;

  C(const int field)
  {
    this->field = field;
  }

  C()
  {
    std::cout << "Default constructor" << std::endl;

    this->field = 0;
  }
}

Answer 5

On the topic of constructors, your first code sample is fine. If the implicitly-generated constructor does the right job (as it does in that sample) then by all means use it.

You might see something like second example in a pedagogical (learning) context where the instructor wants to show what a constructor looks like. Or in old code; the syntax used in your first code sample was not added until C++11.

There are of course other situations where a constructor is necessary, e.g. when the class can take construction arguments, such as std::string x("foo");.

The topic of private vs public is a completely separate issue to the topic of constructors . As mentioned by the other answers you can make data members private if you want your class's code to control every way that they can be modified.