Why is the Size of an Empty Class Not Zero in C++?

When the structure was introduced in C, there was no concept of Objects at that time. So, according to the C standard, it was decided to keep the size of the empty structure to zero. 

In C++, the Size of an empty structure/class is one byte as to call a function at least empty structure/class should have some size (minimum 1 byte is required ) i.e. one byte to make them distinguishable.

Now to understand the size of an empty class, let’s learn what is empty class is first!

Empty class: It is a class that does not contain any data members (e.g. int a, float b, char c, and string d, etc.) However, an empty class may contain member functions. 

Why actually an empty class in C++ takes one byte?

Simply a class without an object requires no space allocated to it. The space is allocated when the class is instantiated, so 1 byte is allocated by the compiler to an object of an empty class for its unique address identification. 

If a class has multiple objects they can have different unique memory locations. Suppose, if a class does not have any size, what would be stored on the memory location? That’s the reason when we create an object of an empty class in a C++ program, it needs some memory to get stored, and the minimum amount of memory that can be reserved is 1 byte. Hence, if we create multiple objects of an empty class, every object will have a unique address.

The code below shows the Size of the Empty Class:

CPP

// C++ program without any compilation
// error to demonstrate the size of
// an Empty Class
#include <iostream>
using namespace std;

// Creating an Empty Class
class Empty_class {
};

// Driver Code
int main()
{
    cout << "Size of Empty Class is = "
         << sizeof(Empty_class);
    return 0;
}

Output

Size of Empty Class is = 1

The size of an empty class is not zero. It is 1 byte generally. It is nonzero to ensure that the two different objects will have different addresses. See the following example. 

CPP

// C++ program without any compilation
// error to demonstrate that the size
// of the two different objects of an
// Empty Class will have different
// addresses
#include <iostream>
using namespace std;

// Creating an Empty class
class Empty {
};

// Driver Code
int main()
{
    Empty a, b;

    if (&a == &b)
        cout << "Impossible " << endl;
    else
        cout << "Fine " << endl;

    return 0;
}

Output

Fine 

For the same reason (different objects should have different addresses), ‘new’ always returns pointers to distinct objects. See the following example. 

C++

// C++ program without any
// compilation error to demonstrate
// that "new" always returns pointers
// to distinct objects
#include <iostream>
using namespace std;

// Creating an Empty Class
class Empty {
};

// Driver Code
int main()
{
    Empty* p1 = new Empty;
    Empty* p2 = new Empty;

    if (p1 == p2)
        cout << "Impossible " << endl;
    else
        cout << "Fine " << endl;

    return 0;
}

Output

Fine 

Now, guess the output of the following program:

CPP

// CPP Program as an exercise

#include <iostream>
using namespace std;

// Creating an Empty Class
class Empty {
};

// Creating a Derived Class
class Derived : Empty {
    int a;
};

// Driver Code
int main()
{
    cout << sizeof(Derived);
    return 0;
}

Output

4

Note: The output is not greater than 4. There is an interesting rule that says that an empty base class need not be represented by a separate byte. So compilers are free to make optimization in case of empty base classes. 

As an exercise, try the following program on your compiler.  

CPP

// CPP Program as an exercise
#include <iostream>
using namespace std;

class Empty {
};

class Derived1 : public Empty {
};

class Derived2 : virtual public Empty {
};

class Derived3 : public Empty {
    char c;
};

class Derived4 : virtual public Empty {
    char c;
};

class Dummy {
    char c;
};

int main()
{
    cout << "sizeof(Empty) " << sizeof(Empty) << endl;
    cout << "sizeof(Derived1) " << sizeof(Derived1) << endl;
    cout << "sizeof(Derived2) " << sizeof(Derived2) << endl;
    cout << "sizeof(Derived3) " << sizeof(Derived3) << endl;
    cout << "sizeof(Derived4) " << sizeof(Derived4) << endl;
    cout << "sizeof(Dummy) " << sizeof(Dummy) << endl;

    return 0;
}

Output

sizeof(Empty) 1
sizeof(Derived1) 1
sizeof(Derived2) 8
sizeof(Derived3) 1
sizeof(Derived4) 16
sizeof(Dummy) 1

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.