I originally wrote some code like this:
class Foo
{
public:
Foo() : m_buffer()
{}
private:
char m_buffer[1024];
};
Someone who is smarter than me said that having the m_buffer() initializer would zero out the memory. My intention was to leave the memory uninitialized. I didn't have time to discuss it further, but it piqued my curiosity.
Previously, I had thought it was wise to always list each member in the initializer list.
Could someone please describe this behavior further?
1) Why does the empty-paren initializer fill in memory?
2) Does it only hold for POD datatypes? I heard that it was so, but don't have the standard handy.
Thanks
If you have a member initialized like that, it will be value-initialized
. That is also true for PODs. For a struct, every member is value-initialized that way, and for an array, every element of it is value-initialized.
Value-initialization for a scalar type like pointer or integer you will have it inialized to 0
converted to the right type. So you will get null pointers or false or whatever type you have concretely.
Note that the rule changed subtly from C++98 to C++03 (what we have right now), which can have surprising effects. C++98 didn't have that value-initialization
. It said default initialization happens, which for a non-POD type always meant it's default constructor invokes. But value-initialization
in C++03 has special meaning if there is no user-declared constructor: Every element is value-initialized then.
Here is the difference:
struct A { int c; ~A() { } }; // non-POD, but no user declared ctor
struct B { A a; B():a(){ } } b;
Now, in C++03, you will be guaranteed that b.a.c
is zero. While in C++98, b.a.c
will have some indeterminated value.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With