Do the C++ standards guarantee that unused private fields will influence sizeof?

Question

Consider the following struct:

class Foo {
    int a;
};

Testing in g++, I get that sizeof(Foo) == 4 but is that guaranteed by the standard? Would a compiler be allowed to notice that a is an unused private field and remove it from the in-memory representation of the class (leading to a smaller sizeof)?

I don't expect any compilers to actually do that kind of optimization but this question popped up in a language lawyering discussion so now I'm curious.

Answer 1

The C++ standard doesn't define a lot about memory layouts. The fundamental rule for this case is item 4 under section 9 Classes:

4 Complete objects and member subobjects of class type shall have nonzero size. [ Note: Class objects can be assigned, passed as arguments to functions, and returned by functions (except objects of classes for which copying or moving has been restricted; see 12.8). Other plausible operators, such as equality comparison, can be defined by the user; see 13.5. — end note ]

Now there is one more restriction, though: Standard-layout classes. (no static elements, no virtuals, same visibility for all members) Section 9.2 Class members requires layout compatibility between different classes for standard-layout classes. This prevents elimination of members from such classes.

For non-trivial non-standard-layout classes I see no further restriction in the standard. The exact behavior of sizeof(), reinterpret_cast(), ... are implementation defined (i.e. 5.2.10 "The mapping function is implementation-defined.").

Answer 2

The answer is yes and no. A compiler could not exhibit exactly that behaviour within the standard, but it could do so partly.

There is no reason at all why a compiler could not optimise away the storage for the struct if that storage is never referenced. If the compiler gets its analysis right, then no program that you could write would ever be able to tell whether the storage exists or not.

However, the compiler cannot report a smaller sizeof() thereby. The standard is pretty clear that objects have to be big enough to hold the bits and bytes they contain (see for example 3.9/4 in N3797), and to report a sizeof smaller than that required to hold an int would be wrong.

At N3797 5.3.2:

The sizeof operator yields the number of bytes in the object representation of its operand

I do not se that 'representation' can change according to whether the struct or member is referenced.

As another way of looking at it:

struct A {
  int i;
};
struct B {
  int i;
};
A a;
a.i = 0;
assert(sizeof(A)==sizeof(B));

I do not see that this assert can be allowed to fail in a standards-conforming implementation.

Answer 3

If you look at templates, you'll notice that "optimization" of such often ends up with nearly nothing in the output even though the template files may be thousands of lines...

I think that the optimization you are talking about will nearly always occur in a function when the object is used on the stack and the object doesn't get copied or passed down to another function and the private field is never accessed (not even initialized... which could be viewed as a bug!)