Question

assuming I have an object similar to this one:

struct MenuDef
{
    int titleResourceId;

    struct MenuItemDef {
        char*               name;
        int                 value;
        SomeFunctionPtr     someFactory;
    } menuItems[10];
};

That is initialized like this:

const MenuDef m = {
    1,
    {
        {
            "zero",
            0,
            (SomeFunctionPtr) & MenuButton::factory,
        },
        {
            "one",
            1,
            (SomeFunctionPtr) & MenuButton::factory,
        },
        {
            "two",
            2,
            (SomeFunctionPtr) & MenuButton::factory,
        },
    }
};

Is it safe to assume that m.menuItems[3].someFactory == 0 ?

for example in a loop like this:

for ( int i = 0; m.menuItems[i].someFactory != 0; ++i)

or do I have to insert a last element to mark the array end by hand just to be safe?

...
        {
            "two",
            2,
            (SomeFunctionPtr) & MenuButton::factory,
        },
        {
            "",
            0,
            (SomeFunctionPtr) 0,
        },
...

Answer 1

I believe it is safe according to 8.5.1/7 :

If there are fewer initializers in the
list than there are members in the
aggregate, then each member not
explicitly initialized shall be
value-initialized (8.5).

As a reminder :

To value-initialize an object of type
T means:

• if T is a class type (clause 9) with a user-declared constructor (12.1),
  then the default constructor for T is
  called (and the initialization is
  ill-formed if T has no accessible
  default constructor);
• if T is a non-union class type without a user-declared constructor,
  then every non-static data member and
  base-class component of T is
  value-initialized;
• if T is an array type, then each element is value-initialized;
• otherwise, the object is zero-initialized