After reading this article I made a point that int ()
yields 0 because the temporary int
is value initialized and not because int()
calls the default constructor for int
. (The article is flawed according to my understanding.)
I also said that primitive (built-in) types don't have constructors. The original author asked me to check Section $10.4.2 (TC++PL) which says
Built-in types also have default constructors ($6.2.8)
But I still think that the statement "C++ allows even built-in type (primitive types) to have default constructors." is flawed (as per C++03).
I think Bjarne in TC++PL has mixed up "constructor like notation i.e ()
" with actual constructor call. Value initialization was not introduced at that time when Bjarne was writing the book, right? So is the text in TC++PL incorrect as per C++98 and C++03?
What do you guys think?
EDIT
I asked Bjarne personally (via mail) regarding the flawed text in TC++PL and this was his reply
I think you mix up "actual constructor calls" with conceptually having a constructor. Built-in types are considered to have constructors (whatever words the standard uses to describe their behavior).
Simple Answer: Technically No.
Long Answer:
No. But!
The syntax you use to initialize them makes them look like they are being constructed by a default constructor or a default copy constructor.
int x0(5); // Looks like a constructor. Behaves like one: x is initialized.
int x1{5};
int y0(); // Fail. Actually a function declaration.
// BUT
int y1{}; // So new syntax to allow for zero initialization
int z0 = int();// Looks like a constructor. Behaves like a constructor (0 init).
int z1 = int{};
int a0(b); // Again.
int a1{b};
So technically there are no constructors for basic-POD types. But for all intents and purposes they act just like they have a copy constructor and default constructor (when initialized with the braces).
If it looks like a duck and quacks like a duck, then its very duck like.