Built-in datatypes versus User defined datatypes in C++

Constructors build objects from dust.

T开发者_如何学Chis is a statement which I have been coming across many times,recently.

While initializing a built-in datatype variable, the variable also HAS to be "built from dust" . So, are there also constructors for built in types?

Also, how does the compiler treat a BUILT IN DATATYPE and a USER DEFINED CLASS differently, while creating instances for each? I mean details regarding constructors, destructors etc.

This query on stack overflow is regarding the same and it has some pretty intresting details , most intresting one being what Bjarne said ... !

Do built-in types have default constructors?

Simply put, according to the C++ standard:

12.1 Constructors [class.ctor]

2. A constructor is used to initialize objects of its class type...

so no, built-in datatypes (assuming you're talking about things like ints and floats) do not have constructors because they are not class types. Class types are are specified as such:

9 Classes [class]

1. A class is a type. Its name becomes a class-name (9.1) within its scope.

        class-name:
                identifier
                template-id

Class-specifiers and elaborated-type-specifiers (7.1.5.3) are used to make class-names. An object of a class consists of a (possibly empty) sequence of members and base class objects.

        class-specifier:
                class-head { member-specification (opt) }

        class-head:
                class-key identifieropt base-clauseopt
                class-key nested-name-specifier identifier base-clauseopt
                class-key nested-name-specifieropt template-id base-clauseopt

        class-key:
                class
                struct
                union

And since the built-in types are not declared like that, they cannot be class types.

So how are instances of built-in types created? The general process of bringing built-in and class instances into existance is called initialization, for which there's a huge 8-page section in the C++ standard (8.5) that lays out in excruciating detail about it. Here's some of the rules you can find in section 8.5.

As already mentioned, built-in data types don't have constructors.

But you still can use construction-like initialization syntax, like in int i(3), or int i = int(). As far as I know that was introduced to language to better support generic programming, i.e. to be able to write

template <class T>
T f() { T t = T(); }

f(42);

While initializing a built-in datatype variable, the variable also HAS to be "built from dust" . So, are there also constructors for built in types?

Per request, I am rebuilding my answer from dust.

I'm not particularly fond of that "Constructors build objects from dust" phrase. It is a bit misleading.

An object, be it a primitive type, a pointer, or a instance of a big class, occupies a certain known amount of memory. That memory must somehow be set aside for the object. In some circumstances, that set-aside memory is initialized. That initialization is what constructors do. They do not set aside (or allocate) the memory needed to store the object. That step is performed before the constructor is called.

There are times when a variable does not have to be initialized. For example,

int some_function (int some argument) {
  int index;
  ...
}

Note that index was not assigned a value. On entry to some_function, a chunk of memory is set aside for the variable index. This memory already exists somewhere; it is just set aside, or allocated. Since the memory already exists somewhere, each bit will have some pre-existing value. If a variable is not initialized, it will have an initial value. The initial value of the variable index might be 42, or 1404197501, or something entirely different.

Some languages provide a default initialization in case the programmer did not specify one. (C and C++ do not.) Sometimes there is nothing wrong with not initializing a variable to a known value. The very next statement might be an assignment statement, for example. The upside of providing a default initialization is that failing to initialize variables is a typical programming mistake. The downside is that this initialization has a cost, albeit typically tiny. That tiny cost can be significant when it occurs in a time-critical, multiply-nested loop. Not providing a default initial value fits the C and C++ philosophy of not providing something the programmer did not ask for.

Some variables, even non-class variables, absolutely do need to be given an initial value. For example, there is no way to assign a value to a variable that is of a reference type except in the declaration statement. The same goes for variables that are declared to be constant.

Some classes have hidden data that absolutely do need to be initialized. Some classes have const or reference data members that absolutely do need to be initialized. These classes need to be initialized, or constructed. Not all classes do need to be initialized. A class or structure that doesn't have any virtual functions, doesn't have an explicitly-provided constructor or destructor, and whose member data are all primitive data types, is called plain old data, or POD. POD classes do not need to be constructed.

Bottom line:

• An object, whether it is a primitive type or an instance of a very complex class, is not "built from dust". Dust is, after all, very harmful to computers. They are built from bits.
• Setting aside, or allocating, memory for some object and initializing that set-aside memory are two different things.
• The memory need to store an object is allocated, not created. The memory already exists. Because that memory already exists, the bits that comprise the object will have some pre-existing values. You should of course never rely on those preexisting values, but they are there.
• The reason for initializing variables, or data members, is to give them a reliable, known value. Sometimes that initialization is just a waste of CPU time. If you didn't ask the compiler to provide such a value, C and C++ assume the omission is intentional.
• The constructor for some object does not allocate the memory needed to store the object itself. That step has already been done by the time the constructor is called. What a constructor does do is to initialize that already allocated memory.

The initial response:

A variable of a primitive type does not have to be "built from dust". The memory to store the variable needs to be allocated, but the variable can be left uninitialized. A constructor does not build the object from dust. A constructor does not allocate the memory needed to store the to-be constructed object. That memory has already been allocated by the time the constructor is called. (A constructor might initialize some pointer data member to memory allocated by the constructor, but the bits occupied by that pointer must already exist.)

Some languages do give an initial value to every variable. C and C++ do not. If you didn't ask for an initial value, C and C++ are not going to force an initial value on the variable. That initialization has a cost, typically tiny, but it exists.

Built In data types(fundamental types, arrays,references, pointers, and enums) do not have constructors.

A constructor is a member function. A member function can only be defined for a class type

C++03 9.3/1:

"Functions declared in the definition of a class, excluding those declared with a friend specifier, are called member functions of that class".

Many a times usage of an POD type in certain syntax's(given below) might give an impression that they are constructed using constructors or copy constructors but it just Initialization without any of the two.

int x(5);