Ch16.1: What Inheritance Is: the Base Subobject

1. A Derived Object Contains a Base Object

struct labeled_point : point does not copy point's code into labeled_point. It makes every labeled_point contain a point, as a part of itself, and calls that part the base subobject. Everything else about inheritance follows from that one sentence.

struct point
{
	::std::int_least32_t x{}, y{};

	[[nodiscard]] ::std::int_least32_t sum() const noexcept { return x + y; }
};

struct labeled_point : point
{
	::std::string_view label{};
};

• p.x and p.y work on a labeled_point: they are members of its base subobject, and name lookup finds them.
• p.sum() works: sum was declared in point and is inherited. Nothing was generated for it in labeled_point.
• sizeof(labeled_point) is at least sizeof(point) plus the new members — here 24, on a machine where point is 8 and a ::std::string_view is 16.
• A labeled_point is a point: a point const& can be bound to it (Ch16.5).

The relation is written from the derived side, and the access specifier in front of the base name is not decoration — it is public, protected or private, and it changes what the rest of the program may do with the relationship (Ch16.3).

2. The is-a Test

Public inheritance is the strongest statement about a type that C++ has: it says the derived type is a base type, for every purpose, forever. Hold the sentence and check it:

The last row is the classic reason to be strict. Public inheritance means the base class's promises hold for the derived object for all callers, including ones written before the derived class existed. “Is-a” is not about the real world; it is about substitutability.

3. Layout: the Base Comes First

A base subobject sits at the start of a derived object with no virtual inheritance involved, which is why a base reference to a derived object needs no adjustment:

No padding is added for the inheritance itself: a derived class with no new data members is exactly as large as its base. That is the empty base optimisation's business and this chapter's last-but-one surprise (Ch16.8).

4. The Whole Program

#include <fast_io.h>
#include <cstdint>
#include <string_view>

struct point
{
	::std::int_least32_t x{}, y{};

	[[nodiscard]] ::std::int_least32_t sum() const noexcept { return x + y; }
};

struct labeled_point : point
{
	::std::string_view label{};
};

int main()
{
	try
	{
		labeled_point p{};
		p.x = 3;
		p.y = 4;
		p.label = "corner";

		::fast_io::io::println(p.label, " ", p.sum());
		::fast_io::io::println("sizeof(point)=", sizeof(point), " sizeof(labeled_point)=", sizeof(labeled_point));

		point const &base{p};
		::fast_io::io::println("base.sum()=", base.sum());
	}
	catch throws (::std::error e)
	{
		::fast_io::io::perrln(e);
	}
}

Output:

corner 7
sizeof(point)=8 sizeof(labeled_point)=24
base.sum()=7

The third line is the interesting one: base is a reference to the point subobject inside p, not to a copy, and it was created without a cast.

5. Rules of Thumb

• Say the is-a sentence out loud before writing the colon. If it is not literally true for every caller, use a member instead.
• Write : public base explicitly; on a struct the public is implied, and on a class the opposite is, so the word prevents a silent change of meaning when someone edits struct to class.
• Keep base classes small and self-contained. Everything you put in a base class is inherited by everything below it, including invariants that future code must maintain.
• Do not use inheritance to reuse code. A base class is a type, not a macro; reuse is what functions and templates are for.
• Do not inherit from a type you do not own unless its author documented that it is a base class (a public, non-virtual destructor being the usual sign the opposite is intended).