Why do C++ classes without member variables occupy space?

Question

I found that both MSVC and GCC compilers allocate at least one byte per each class instance even if the class is a predicate with no member variables (or with just static member variables). The following code illustrates the point.

#include <iostream>  class A { public:    bool operator()(int x) const    {       return x>0;    } };  class B { public:    static int v;    static bool check(int x)    {       return x>0;    } };  int B::v = 0;  void test() {    A a;    B b;    std::cout << "sizeof(A)=" << sizeof(A) << "\n"              << "sizeof(a)=" << sizeof(a) << "\n"              << "sizeof(B)=" << sizeof(B) << "\n"              << "sizeof(b)=" << sizeof(b) << "\n"; }  int main() {    test();    return 0; } 

Output:

sizeof(A)=1 sizeof(a)=1 sizeof(B)=1 sizeof(b)=1 

My question is why does compiler need it? The only reason that I can come up with is ensure that all member var pointers differ so we can distinguish between two members of type A or B by comparing pointers to them. But the cost of this is quite severe when dealing with small-size containers. Considering possible data alignment, we can get up to 16 bytes per class without vars (?!). Suppose we have a custom container that will typically hold a few int values. Then consider an array of such containers (with about 1000000 members). The overhead will be 16*1000000! A typical case where it can happen is a container class with a comparison predicate stored in a member variable. Also, considering that a class instance should always occupy some space, what type of overhead should be expected when calling A()(value) ?

Answer 1

It’s necessary to satisfy an invariant from the C++ standard: every C++ object of the same type needs to have a unique address to be identifiable.

If objects took up no space, then items in an array would share the same address.

Answer 2

Basically, it's an interplay between two requirements:

• Two different objects of the same type must be at a different addresses.
• In arrays, there may not be any padding between objects.

Note that the first condition alone does not require non-zero size: Given

struct empty {}; struct foo { empty a, b; }; 

the the first requirement could easily be met by having a zero-size a followed by a single padding byte to enforce a different address, followed by a zero-size b. However, given

empty array[2]; 

that no longer works because a padding between the different objects empty[0] and empty[1] would not be allowed.