Default Constructors

Question

I know that default constructors initialize objects to their default values, but how do we view these values? If there's a variable of type int, it is supposed to be initialized to 0. But how do we actually view these default values of the constructors? Can anyone please provide a code snippet to demonstrate the same?

Answer 1

Good coding practice: write your own constructor, so you know how it will be initialized. This is portable and guaranteed to always have the same behaviour. Your code will be easier to read and the compiler knows how to make that efficient, especially when using the special notation:

class Foo
{
  public:
    Foo() : i(0), j(0) {}

  private:
    int i;
    int j;
};

Answer 2

Unless specified otherwise, objects are constructed with their default constructor, only if one is available.

And for example ints are not initialized.

This is a common source of huge troubles and bugs, because it can have any value.

So the rule is , always initialise your variables, and for a class you do it in the initialization list

class A
{
private:
    int i;
    float f;
    char * pC;
    MyObjectType myObject;
public:
    A() :   // the initialisation list is after the :
    i(0),
    f(2.5),
    pC(NULL),
    myObject("parameter_for_special_constructor")  
    {}
}

}

Answer 3

Default constructors do not automatically initialise ints to 0. You can use parentheses to indicate the default value though.

struct X
{
   int x;
};

struct X x1; // x1.x is not necessarily 0

struct Y
{
   int y;
   Y() : y()
   {
   }
};

struct Y y1; // y1.y will be 0

Answer 4

show your code

And if your int value is a member of class . you must give it a value in your default constructor func

Answer 5

In C++, int is not a class and does not have a default (or any other) constructor.

An int is not guaranteed to be initialised to 0.

If you have a class that has an int as an attribute, you should explicitly initialise it in each of the class's constructors (not just the default one).

class sample
{
private:
    int x;
public:
    sample()
        :x(0)
    {
    }

    sample(const int n)
        :x(n)
    {
    }

    sample(const sample& other)
        :x(other.x)
    {
    }

    // [...]
};

This way you (and users of your class) can "view" the default values.

Answer 6

The default constructor is which can be invoked with 0 parameters. For example

struct X
{
   X(int x = 3) //default constructor
   {
     //...
   }
};

It initializes the object to whichever state you code it to initialize. However, if you don't define any constructor at all the compiler will attempt to generate a default constructor for you - which, in turn is equivalent to a constructor with no arguments and no body. That means that all the members of class/struct type will be initialized with their def. ctors and all the members of primitive types like int will remain uninitialized. Please note that I specialy noted that the compiler will attempt to generate a dflt ctor, because it can fail to do so, for example when one or more members of the class do not have default constructors. HTH

Answer 7

AFAIK, if T is a type (not necessarily a class), T() returns a default value for the type T. Here's a small test I ran:

int main()
{
    char c = char();
    int i  = int();

    cout << "c = " << hex << (int) c << endl;
    cout << "i = " << i << endl;
}

The output is:

c = 0
i = 0

Answer 8

AS soon as you have created an object start printing the values such as ob.x. Thats the only way u can know what default constructor has assigned to the variables.