Understanding sizeof in C+ + : Object Size of Base Class vs. Derived Class

Описание: In this guide, we explore why using `sizeof` on a base class pointer to a derived class object returns the base class size. Learn how static typing in C+ + affects object size calculations.
---
This video is based on the question https://stackoverflow.com/q/64768258/ asked by the user 'wholesome' ( https://stackoverflow.com/u/14610397/ ) and on the answer https://stackoverflow.com/a/64768330/ provided by the user 'lubgr' ( https://stackoverflow.com/u/9593596/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Object size of base class while referring to derived class

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding sizeof in C+ + : Object Size of Base Class vs. Derived Class

When working with inheritance in C+ + , you might come across a scenario that leaves you puzzled: Why does the sizeof operator return the size of a base class even when it's pointing to an object of a derived class? Let's break this down and clarify the mechanics at play through an example.

The Problem

Consider the following C+ + code example:

[[See Video to Reveal this Text or Code Snippet]]

Now, if we run this code, we see sizeof(*ob) returns 4. This seems perplexing since we might assume that since ob points to an object of the derived class xyz, the size should reflect that of the xyz class, which totals 20. So, what exactly is happening?

The Explanation

The sizeof operator in C+ + works on static types rather than dynamic types. This means it evaluates the size based on the declared type of the object rather than the type of object it points to at runtime. Here's a detailed explanation:

Key Concepts

Static vs. Dynamic Types:

Static Type: The type that is declared in the code. In this case, ob is a pointer of type abc*, which is the base class.

Dynamic Type: The type of the object that is actually being pointed to at runtime. Here, it's an instance of xyz.

When sizeof is Evaluated:

The sizeof operator is executed at compile time. The compiler determines the size based solely on the static type of the pointer, which is abc in our case.

Since abc only contains one integer (int a), its size is 4 bytes (assuming typical sizes for integers).

Compiler Limitations:

The compiler does not have the ability to determine the dynamic type when performing sizeof in a different translation unit. Essentially, it doesn’t know if xyz is a valid class or its size since it might not have visibility of that declaration at the point of evaluation.

Practical Implications

If you need to work with the size of derived class objects through base class pointer, consider using the sizeof operator in a context aware of the derived class or using polymorphism with virtual functions for behavior dependent on dynamic types.

In cases where you require dynamic checks or operations based on the actual type of the object pointed to, look into the use of dynamic_cast for type-safe downcasting.

Conclusion

Understanding the behavior of the sizeof operator in the context of inherited classes in C+ + is crucial for effective programming. As demonstrated, the operator calculates size based on static types, which can lead to unexpected results if one assumes it would consider the dynamic type instead. Keep these concepts in mind while designing your classes to avoid confusion and improve your code’s reliability.

In summary, remember:

sizeof only works with the static type of the pointer.

The dynamic type does not influence compile-time size calculation.

By being aware of these aspects of C+ + , you can better leverage the language's features and avoid common pitfalls. Happy coding!