Question

#include <iostream>

class MyClass
{
public:
    MyClass() :
        mFirst()
    {
    }

    int mFirst;
    int mSecond;
};


int main()
{
    MyClass mc;
    std::cout << "mc.mFirst: " << mc.mFirst << std::endl;
    std::cout << "mc.mSecond: " << mc.mSecond << std::endl;

    int a;
    std::cout << "a: " << a << std::endl;
    return 0;
}

What is the expected output of this program?

I would think only MyClass.mFirst will be initialized to zero. However GCC initializes them all to zero, even with optimizations enabled:

$ g++ -o test -O3 main.cpp
$ ./test
mc.mFirst: 0
mc.mSecond: 0
a: 0

I’d like to know:

1. How is each value initialized according to the C++ standard?
2. Why does GCC initialize them all to zero?

Update

According to Erik the values are zero because my stack happens to contain zeroes. I tried forcing the stack to be non-zero using this construct:

int main()
{
    // Fill the stack with non-zeroes
    {
        int a[100];
        memset(a, !0, sizeof(a));
    }
    MyClass mc;
    std::cout << "mc.mFirst: " << mc.mFirst << std::endl;
    std::cout << "mc.mSecond: " << mc.mSecond << std::endl;

    int a;
    std::cout << "a: " << a << std::endl;
    return 0;
}

However, the output stays the same:

mc.mFirst: 0
mc.mSecond: 0
a: 0

Can anyone explain why?

Update 2

Ok I figured it out. GCC was probably optimizing away unused variables.

This application shows the expected behavior:

#include <iostream>

struct MyClass
{
    MyClass() : mFirst() { }

    MyClass(int inFirst, int inSecond) : mFirst(inFirst), mSecond(inSecond) { }

    int mFirst;
    int mSecond;
};


int main()
{
    // Fill the stack with non-zeroes
    // Use volatile to prevent GCC optimizations.
    {
        volatile MyClass mc(1, 2);
        volatile int a = 3;
    }

    {
        volatile MyClass mc;
        volatile int a;

        std::cout << "mc.mFirst: " << mc.mFirst << std::endl;
        std::cout << "mc.mSecond: " << mc.mSecond << std::endl;
        std::cout << "a: " << a << std::endl;
    }
    return 0;
}

Output:

$ g++ -o test main.cpp
$ ./test 
mc.mFirst: 0
mc.mSecond: 2
a: 3

Answer 1

They’re (EDIT: With “They” i refer to mSecond and a which are not explicitly initialized) not initialized. Your stack happens to contain 0’s so that’s the values you get.

8.5/9:

If no initializer is specified for an
object, and the object is of (possibly
cv-qualified) non-POD class type (or
array thereof), the object shall be
default-initialized; if the object is
of const-qualified type, the
underlying class type shall have a
user-declared default constructor.
Otherwise, if no initializer is
specified for a nonstatic object, the
object and its subobjects, if any,
have an indeterminate initial
value; if the object or any of its
subobjects are of const-qualified
type, the program is ill-formed.