Dynamic type

Polymorphic type - has at least one direct or inherited (potentially final or abstract) virtual function.

 class Polymorphic1 {
    virtual void f() {}
}
class Polymorphic2 : public Polymorphic1 {
}
class Polymorphic3 {
    virtual void f() final {}
}
class Polymorphic4 {
    virtual void f() = 0;
}

Static type - compile time
Dynamic type - runtime

 class Base {
public:
   virtual ~Base();
};
class Derived : public Base {
}

 Base* p = new Derived;
// static type Base
// dynamic type Derived

dynamic_cast

 Base* b = new Derived1();
auto s_d1 = static_cast<Derived1*>(b);
auto s_d2 = static_cast<Derived2*>(b); // UB
auto d_d1 = dynamic_cast<Derived1*>(b);
auto d_d2 = dynamic_cast<Derived2*>(b); // nullptr

 Base* b = new Derived1();
Base& b_ref = *b;
 
auto s_d1 = static_cast<Derived1&>(b_ref);
auto s_d2 = static_cast<Derived2&>(b_ref); // UB
auto d_d1 = dynamic_cast<Derived1&>(b_ref);
auto d_d2 = dynamic_cast<Derived2&>(b_ref); // throw std::bad_cast

multiple inheritance

computer

Turing machine
Electronic device

is-a

 class TuringMachine {
private:
    InfiniteArray<state> _tape;
    state _current_state;
public:
    TuringMachine() :
        _tape{ state::empty },
        _current_state{ state::start_state }
    {
    }
 
    struct transition_result {
        state new_state;
        state new_symbol;
        enum {
            Left, Right, None
        } tape_movement;
    };
    
    virtual transition_result transition(const state& current_state, const state& symbol) = 0;
};

class Computer : public TuringMachine { ... };

multiple inheritance

computer

Turing machine
Electronic device

is-a

 class TuringMachine {
    ...
};
 
class ElectronicDevice {
    ...
};

class Computer : public TuringMachine, public ElectronicDevice {
    ...
};

multiple inheritance

class Derived : public Base1, public Base2, public BaseN {
    ...
};

 struct Base1 {
    void b1();
};
struct Base2 {
    int b2 = 3;
};
struct Derived : Base1, Base2 {
};
 
void foo() {
    Derived d;
    d.b1();
    d.b2 = 3;
}

 struct Base1 {
    void b1();
};
struct Base2 {
protected:
    int b2 = 3;
};
struct Derived : Base1, Base2 {
    using Base2::b2;
};
 
void foo() {
    Derived d;
    d.b1();
    d.b2 = 3;
}

using declaration

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

👀

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.print(3);    // ambiguous
    d.print(2.0f); // ambiguous
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

Name lookup

ambiguous

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
};
 
 
 
void foo() {
    Derived d;
    d.Base1::print(3);    // i
    d.Base2::print(2.0f); // f
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Derived::print

Base1::print

Base2::print

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
    using Base1::print;
};
 
 
void foo() {
    Derived d;
    d.print(3);    // i
    d.print(2.0f); // i
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Base1::print

Base1::print

Base2::print

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
    using Base1::print;
    using Base2::print;
};
 
void foo() {
    Derived d;
    d.print(3);    // i
    d.print(2.0f); // f
}

shadowing / dominance

d.print()

Derived

Base1

Base2

Base1::print
Base2::print

Base1::print

Base2::print

Name lookup

 struct Base1 {
    void print(int) {
        std::cout << "i\n";
    }
};
struct Base2 {
    void print(float) {
        std::cout << "f\n";
    }
};
struct Derived : Base1, Base2 {
    using Base1::print;
    using Base2::print;
};
 
void foo() {
    Derived d;
    d.print(3);    // i
    d.print(2.0f); // f
}

shadowing / dominance

print(float)
print(int)

overload set

Overload resolution

d.print(3)
d.print(2.0f)

print(int)
print(float)

 struct Adder {
    float toAdd;
    Adder(float val) : toAdd{val} {}
    int operator()(float x) const { 
        return x + toAdd;
    }
};
struct Fib {
    std::vector<int> sequence;
    Fib(size_t count) :
    	sequence{ create_seq(count) }
    {
    }
private:
    ...
};

base class initialisation

 struct Derived : Adder, Fib {};
 
void foo() {
    Derived d; // error: no default ctor
    Derived d{3.0f, 2}; // ok: implicit conversion
}

 struct Adder {
    float toAdd;
    explicit Adder(float val) : toAdd{val} {}
    int operator()(float x) const { 
        return x + toAdd;
    }
};
struct Fib {
    std::vector<int> sequence;
    explicit Fib(size_t count) :
    	sequence{ create_seq(count) }
    {
    }
private:
    ...
};

base class initialisation

 struct Derived : Adder, Fib {};
 
void foo() {
    Derived d; // error: no default ctor
    Derived d{3.0f, 2}; // error: no conversion
    Derived d{Adder{3.0f}, Fib{2}} // ok
}

 struct Adder {
    float toAdd;
    explicit Adder(float val) : toAdd{val} {}
    int operator()(float x) const { 
        return x + toAdd;
    }
};
struct Fib {
    std::vector<int> sequence;
    explicit Fib(size_t count) :
    	sequence{ create_seq(count) }
    {
    }
private:
    ...
};

base class initialisation

 struct Derived : Adder, Fib {
    int x;
    Derived(int toAdd, size_t count) :
    	Adder{toAdd},
        Fib{count},
        x{42} // after base classes
    {
    }
};
 
void foo() {
    Derived d; // error: no default ctor
    Derived d{3.0f, 2}; //  ok
}

 struct Adder {
    float toAdd;
    explicit Adder(float val = .0f) : toAdd{val} {}
    int operator()(float x) const { 
        return x + toAdd;
    }
};
struct Fib {
    std::vector<int> sequence;
    explicit Fib(size_t count = 0) :
    	sequence{ create_seq(count) }
    {
    }
private:
    ...
};

base class initialisation

 struct Derived : Adder, Fib {
    using Adder::Adder;
    using Fib::Fib;
};
 
void foo() {
    Derived d1;
    Derived d2{3.0f};
    Derived d3{size_t(2)};
    Derived d3{2uz}; // since C++23
}

Multiple inheritance AND Interfaces

Interfaces

multiple inheritance

 class IPrintable {
public:
    virtual void print() const = 0;
};
class IMeowable {
    virtual void moew() const noexcept = 0;
};

 class MeowingCatPhoto : public Image, public IPrintable, public IMeowable {
public:
    virtual void print() const override {
        Pixel* pixels = getPixels();
        ...
    }
    virtual void moew() const noexcept override {
        ...
    }
}

 struct Pixel {
    float r, g, b;
};
class Image {
    using data_t = Pixel[768][1024];
    data_t pixels;
public:
    [[nodiscard]] const Pixel* getPixels() const noexcept;
    ...
};

memory layout

derived*

 struct Base {
    int x, y;
};
struct Derived : Base {
    int z, w;
};

Base*

 Derived der;
Base* pBase = &der;
Derived* pDerived = static_cast<Derived*>(pBase);

memory layout

derived*

 struct Base {
    int x, y;
    virtual void foo() {}
};
struct Derived : Base {
    int z, w;
};

Base*

VFTablePtr

 Derived der;
Base* pBase = &der;
Derived* pDerived = static_cast<Derived*>(pBase);

memory layout

derived*

Base*

VFTablePtr

 struct Base {
    int x, y;
    virtual void foo() {}
};
struct Derived : Base {
    int z, w;
};
struct Base2 {
    int a, b;
}
struct Derived2 : Derived, Base2 {
    int g;
}

 Derived2 d2;
 
Derived* pDerived = &d2;
Base2* pBase2 = &d2;
Base* pBase = &d2;
 
auto* p_derived = static_cast<Derived2*>(pBase2);
auto* p_derived2 = static_cast<Derived2*>(pDerived);
auto* p_derived3 = static_cast<Derived2*>(pBase);

derived2*

Base2*

memory layout

derived*

Base*

...

...

VFTablePtr

 struct Base {
    ...
    virtual void foo() {}
};
struct Derived : Base {
    ...
};
struct Base2 {
    ...
}
struct Derived2 : Derived, Base2 {
    ...
}

 Derived2 d2;
 
Derived* pDerived = &d2;
Base2* pBase2 = &d2;
Base* pBase = &d2;
 
auto* p_derived = static_cast<Derived2*>(pBase2);
auto* p_derived2 = static_cast<Derived2*>(pDerived);
auto* p_derived3 = static_cast<Derived2*>(pBase);

...

...

derived2*

Base2*

memory layout

derived*

Base*

...

...

VFTablePtr

...

...

derived2*

Base2*

 auto* p_derived = static_cast<Derived2*>(pBase2);
..B7A  cmp    qword ptr [pBase2],0  
..B82  je     main+0A8h (07FF720981B98h)  
..B84  mov    rax,qword ptr [pBase2]  
..B8B  sub    rax,28h  
..B8F  mov    qword ptr [rbp+1D8h],rax  
..B96  jmp    main+0B3h (07FF720981BA3h)  
..B98  mov    qword ptr [rbp+1D8h],0  
..BA3  mov    rax,qword ptr [rbp+1D8h]  
..BAA  mov    qword ptr [p_derived],rax  
auto* p_derived2 = static_cast<Derived2*>(pDerived);
..BB1  mov    rax,qword ptr [pDerived]  
..BB5  mov    qword ptr [p_derived2],rax

 struct Base {
    ...
    virtual void foo() {}
};
struct Derived : Base {
    ...
};
struct Base2 {
    ...
}
struct Derived2 : Derived, Base2 {
    ...
}

 Derived2 d2;
 
Derived* pDerived = &d2;
Base2* pBase2 = &d2;
Base* pBase = &d2;
 
auto* p_derived = static_cast<Derived2*>(pBase2);
auto* p_derived2 = static_cast<Derived2*>(pDerived);
auto* p_derived3 = static_cast<Derived2*>(pBase);

memory layout

derived*

Base*

...

...

VFTablePtr

...

...

derived2*

Base2*

 struct Base {
    ...
    virtual void foo() {}
};
struct Derived : Base {
    ...
};
struct Base2 {
    ...
    virtual void bar() {}
}
struct Derived2 : Derived, Base2 {
    ...
}

VFTablePtr

 Derived2 d2;
 
Derived* pDerived = &d2;
Base* pBase = &d2;
Base2* pBase2 = &d2;
 
pDerived->foo();
pBase->foo();
pBase2->bar();

the diamond problem

 class Base {
    ...
};
class Derived1 : public Base {
    ...
};
class Derived2 : public Base {
    ...
};
class Derived12 : public Derived1, public Derived2 {
    ...
};

the diamond problem

 class Base { ... };
class Derived1 : public Base { ... };
class Derived2 : public Base { ... };
class Derived12 : public Derived1, public Derived2 { ... };

derived1

Derived1::Base

...

...

...

...

derived12

Derived2

Derived2::Base

...

the diamond problem

 struct Base {
    void bar() {}
};
struct Derived1 : Base { };
struct Derived2 : Base { };
struct Derived12 : Derived1, Derived2 { };

 Derived12 d;
 
d.bar(); // ambiguous
d.Derived1::bar();
d.Derived2::bar();
 
auto pBase = static_cast<Base*>(&d); // ambiguous
auto pBase1 = static_cast<Base*>(static_cast<Derived1*>(&d));
auto pBase2 = static_cast<Base*>(static_cast<Derived2*>(&d));
 
auto pD12 = static_cast<Derived12*>(pBase); // ambiguous
auto pD12_1 = static_cast<Derived12*>(static_cast<Derived1*>(pBase);
auto pD12_2 = static_cast<Derived12*>(static_cast<Derived1*>(pBase);

d.bar()

Derived12

Derived1

Derived1

Base

Base

ambiguous

the diamond problem

 struct Base {
    virtual void bar() = 0;
};
struct Derived1 : Base { };
struct Derived2 : Base { };
struct Derived12 : Derived1, Derived2 { 
	virtual void bar() override {
        std::cout << "d12\n";
    }
};

 Derived12 d;
 
auto pDerived1 = static_cast<Derived1*>(&d);
auto pDerived2 = static_cast<Derived2*>(&d);
 
auto pBase1 = static_cast<Base*>(pDerived1);
auto pBase2 = static_cast<Base*>(pDerived2);
 
pDerived1->bar(); // ok
pDerived2->bar(); // ok
pBase1->bar(); // ok
pBase2->bar(); // ok

derived1

Derived1::Base

derived12

Derived2

Derived2::Base

VFTablePtr

VFTablePtr

the diamond problem

 struct Base {
    virtual void bar() = 0;
};
struct Derived1 : Base { };
struct Derived2 : Base { };
struct Derived12 : Derived1, Derived2 { 
	virtual void bar() override {
        std::cout << "d12\n";
    }
};

 Derived12 d;
 
auto pDerived1 = static_cast<Derived1*>(&d);
auto pDerived2 = static_cast<Derived2*>(&d);
 
auto pBase1 = static_cast<Base*>(pDerived1);
auto pBase2 = static_cast<Base*>(pDerived2);
 
pDerived1->bar(); // ok
pDerived2->bar(); // ok
pBase1->bar(); // ok
pBase2->bar(); // ok

derived1

Derived1::Base

derived12

Derived2

Derived2::Base

VFTablePtr

VFTablePtr

Still two Base instances

virtual inheritance

 struct Base {
    virtual void bar() = 0;
};
struct Derived1 : virtual Base { }; // instrusive
struct Derived2 : virtual Base { }; // instrusive
struct Derived12 : Derived1, Derived2 { 
	virtual void bar() override {
        std::cout << "d12\n";
    }
};

derived1

derived12

Derived2

Base

VFTablePtr

virtual inheritance

VBasePtr

VBasePtr

 Derived12 d12;
 
Derived1* pd1 = &d12;
Derived2* pd2 = &d12;
Base* pb = &d12;

virtual inheritance

 struct Base {
    virtual void bar() = 0;
};
struct Derived1 : virtual Base { }; // instrusive
struct Derived2 : virtual Base { }; // instrusive
struct Derived12 : Derived1, Derived2 { 
	virtual void bar() override {
        std::cout << "d12\n";
    }
};

derived1

derived12

Derived2

Base

VFTablePtr

virtual inheritance

VBasePtr

VBasePtr

 Derived12 d12;
 
Derived1* pd1 = &d12;
Derived2* pd2 = &d12;
Base* pb = &d12;

 auto pd12_1 = static_cast<Derived12*>(pd1); // ok
auto pd12_2 = static_cast<Derived12*>(pd1); // ok
auto pd12_3 = static_cast<Derived12*>(pb); // no, why??..

virtual inheritance

 struct Base {
    virtual void bar() = 0;
};
struct Derived1 : virtual Base { }; // instrusive
struct Derived2 : virtual Base { }; // instrusive
struct Derived12 : Derived1, Derived2 { 
	virtual void bar() override {
        std::cout << "d12\n";
    }
};

derived1

derived12

Derived2

Base

VFTablePtr

virtual inheritance

VBasePtr

VBasePtr

 Derived12 d12;
 
Derived1* pd1 = &d12;
Derived2* pd2 = &d12;
Base* pb = &d12;

 auto pd12_1 = static_cast<Derived12*>(pd1); // ok
auto pd12_2 = static_cast<Derived12*>(pd1); // ok
auto pd12_3 = dynamic_cast<Derived12*>(pb); // ok

virtual inheritance

 struct B {
    B() = delete;
    B(int);
};
struct D1 : virtual B {
    D1(int x) : B(x) {}
};
struct D2 : virtual B {
    D2(int x) : B(x) {}
};

virtual inheritance

 struct D12 : D1, D2 {
    D12(int x) : B(x), D1(x), D2(x) {}
};

 struct D12 : D1, D2 {
    D12(int x) : D1(x), D2(x) {}
};

 struct D : virtual B, D1, D2 {
    D(int x) : B(x), D1(x) {}
};

virtual inheritance

 struct B {
    B() = default;
    B(int);
};
struct D1 : virtual B {
    D1(int x) : B(x) {}
};
struct D2 : virtual B {
    D2(int x) : B(x) {}
};

virtual inheritance

 struct D12 : D1, D2 {
    D12(int x) : B(x), D1(x), D2(x) {}
};

 struct D12 : D1, D2 {
    D12(int x) : D1(x), D2(x) {}
};

 struct D : virtual B, D1, D2 {
    D(int x) : B(x), D1(x) {}
};

virtual base classes should be default-constructible

base class construction order

struct AmphibiousSchoolBus : SchoolBus, AmphibiousVehicle

struct SchoolBus : SchoolVehicle, Bus

struct SchoolVehicle : virtual LandVehicle

struct Bus : WheeledVehicle

struct WheeledVehicle : virtual LandVehicle

struct Vehicle

struct AmphibiousVehicle : virtual LandVehicle, virtual WaterVehicle

struct LandVehicle : virtual Vehicle

struct WaterVehicle : virtual Vehicle

base class construction order

AmphibiousSchoolBus

SchoolBus

AmphibiousVehicle

SchoolVehicle

Bus

LandVehicle

WaterVehicle

LandVehicle

WheeledVehicle

Vehicle

Vehicle

Vehicle

Vehicle

1

2

3

4

5

6

7

8

9

(Left to right DFS)

multiple inheritance

rtti

multiple inheritance, inheriting (non)abstract classes
the diamond problem
virtual inheritance
delegation to sister class
polymorphic object
base class subobjects and addresses, rtti pointer
static type and dynamic type
<typeinfo>, typeid, std::type_info, std::bad_typeid
std::type_info::hash_code, std::type_index
std::type_info::name(), symbol (de)mangling
dynamic_cast, downcast, upcast, sidecast, std::bad_cast
std::variant, std::monostate, std::bad_variant_access
std::any, std::any_cast

RAII

inheritance

virtual

constructor
member initializer list
destructor
default constructor
std::initializer_list
in-class initializer
copy ctor
cpy assign op
move ctor
mv assign op
default members
deleted members
rule of 0
rule of 3/5
smart-ptrs
converting constructor
explicit specifier

is-a relation
has-a relation
public inheritance
protected members
using declaration
final specifier
private & protected inheritance
multiple inheritance
diamond problem
empty base optimization

base method hiding problem (shadowing)
virtual methods
override specifier
dynamic type
- RTTI
- dynamic_cast
- typeid
- vtables
by value passing problem (slicing)
pure virtual function
abstract class

misc

friends
nested members
conversion operators
operator overloading
member pointers
unions
- std optional
- std variant
- std any

type ereasure

pimpl

enable shared from this with private inheritance

linkage and static (non-member) functions

Liskov substitution principle

function member ref qualification

constexpr virtual

virtual inheritance

aggregate, pod, literal type

implement class in cpp file

	class Polymorphic1 {
	virtual void f() {}
	}
	class Polymorphic2 : public Polymorphic1 {
	}
	class Polymorphic3 {
	virtual void f() final {}
	}
	class Polymorphic4 {
	virtual void f() = 0;
	}

	class Base {
	public:
	virtual ~Base();
	};
	class Derived : public Base {
	}

	Base* p = new Derived;
	// static type Base
	// dynamic type Derived

	Base* b = new Derived1();
	auto s_d1 = static_cast<Derived1*>(b);
	auto s_d2 = static_cast<Derived2*>(b); // UB
	auto d_d1 = dynamic_cast<Derived1*>(b);
	auto d_d2 = dynamic_cast<Derived2*>(b); // nullptr

	Base* b = new Derived1();
	Base& b_ref = *b;

	auto s_d1 = static_cast<Derived1&>(b_ref);
	auto s_d2 = static_cast<Derived2&>(b_ref); // UB
	auto d_d1 = dynamic_cast<Derived1&>(b_ref);
	auto d_d2 = dynamic_cast<Derived2&>(b_ref); // throw std::bad_cast

	class TuringMachine {
	private:
	InfiniteArray<state> _tape;
	state _current_state;
	public:
	TuringMachine() :
	_tape{ state::empty },
	_current_state{ state::start_state }
	{
	}

	struct transition_result {
	state new_state;
	state new_symbol;
	enum {
	Left, Right, None
	} tape_movement;
	};

	virtual transition_result transition(const state& current_state, const state& symbol) = 0;
	};

	struct Base1 {
	void b1();
	};
	struct Base2 {
	int b2 = 3;
	};
	struct Derived : Base1, Base2 {
	};

	void foo() {
	Derived d;
	d.b1();
	d.b2 = 3;
	}

	struct Base1 {
	void print(int) {
	std::cout << "i\n";
	}
	};
	struct Base2 {
	void print(float) {
	std::cout << "f\n";
	}
	};
	struct Derived : Base1, Base2 {
	};



	void foo() {
	Derived d;
	d.print(3); // ambiguous
	d.print(2.0f); // ambiguous
	}

	struct Adder {
	float toAdd;
	Adder(float val) : toAdd{val} {}
	int operator()(float x) const {
	return x + toAdd;
	}
	};
	struct Fib {
	std::vector<int> sequence;
	Fib(size_t count) :
	sequence{ create_seq(count) }
	{
	}
	private:
	...
	};

	struct Derived : Adder, Fib {};

	void foo() {
	Derived d; // error: no default ctor
	Derived d{3.0f, 2}; // ok: implicit conversion
	}

	struct Adder {
	float toAdd;
	explicit Adder(float val) : toAdd{val} {}
	int operator()(float x) const {
	return x + toAdd;
	}
	};
	struct Fib {
	std::vector<int> sequence;
	explicit Fib(size_t count) :
	sequence{ create_seq(count) }
	{
	}
	private:
	...
	};

	struct Derived : Adder, Fib {
	int x;
	Derived(int toAdd, size_t count) :
	Adder{toAdd},
	Fib{count},
	x{42} // after base classes
	{
	}
	};

	void foo() {
	Derived d; // error: no default ctor
	Derived d{3.0f, 2}; // ok
	}

	struct Adder {
	float toAdd;
	explicit Adder(float val = .0f) : toAdd{val} {}
	int operator()(float x) const {
	return x + toAdd;
	}
	};
	struct Fib {
	std::vector<int> sequence;
	explicit Fib(size_t count = 0) :
	sequence{ create_seq(count) }
	{
	}
	private:
	...
	};

	struct Derived : Adder, Fib {
	using Adder::Adder;
	using Fib::Fib;
	};

	void foo() {
	Derived d1;
	Derived d2{3.0f};
	Derived d3{size_t(2)};
	Derived d3{2uz}; // since C++23
	}

	class IPrintable {
	public:
	virtual void print() const = 0;
	};
	class IMeowable {
	virtual void moew() const noexcept = 0;
	};

	class MeowingCatPhoto : public Image, public IPrintable, public IMeowable {
	public:
	virtual void print() const override {
	Pixel* pixels = getPixels();
	...
	}
	virtual void moew() const noexcept override {
	...
	}
	}

	struct Pixel {
	float r, g, b;
	};
	class Image {
	using data_t = Pixel[768][1024];
	data_t pixels;
	public:
	[[nodiscard]] const Pixel* getPixels() const noexcept;
	...
	};

	Derived der;
	Base* pBase = &der;
	Derived* pDerived = static_cast<Derived*>(pBase);

	struct Base {
	int x, y;
	virtual void foo() {}
	};
	struct Derived : Base {
	int z, w;
	};

	Derived2 d2;

	Derived* pDerived = &d2;
	Base2* pBase2 = &d2;
	Base* pBase = &d2;

	auto* p_derived = static_cast<Derived2*>(pBase2);
	auto* p_derived2 = static_cast<Derived2*>(pDerived);
	auto* p_derived3 = static_cast<Derived2*>(pBase);

multiple inheritance

Multiple Inheritance

More from Jan Bielak

	auto* p_derived = static_cast<Derived2*>(pBase2);
	..B7A cmp qword ptr [pBase2],0
	..B82 je main+0A8h (07FF720981B98h)
	..B84 mov rax,qword ptr [pBase2]
	..B8B sub rax,28h
	..B8F mov qword ptr [rbp+1D8h],rax
	..B96 jmp main+0B3h (07FF720981BA3h)
	..B98 mov qword ptr [rbp+1D8h],0
	..BA3 mov rax,qword ptr [rbp+1D8h]
	..BAA mov qword ptr [p_derived],rax
	auto* p_derived2 = static_cast<Derived2*>(pDerived);
	..BB1 mov rax,qword ptr [pDerived]
	..BB5 mov qword ptr [p_derived2],rax

	class Base {
	...
	};
	class Derived1 : public Base {
	...
	};
	class Derived2 : public Base {
	...
	};
	class Derived12 : public Derived1, public Derived2 {
	...
	};

	class Base { ... };
	class Derived1 : public Base { ... };
	class Derived2 : public Base { ... };
	class Derived12 : public Derived1, public Derived2 { ... };

	struct Base {
	void bar() {}
	};
	struct Derived1 : Base { };
	struct Derived2 : Base { };
	struct Derived12 : Derived1, Derived2 { };

	Derived12 d;

	d.bar(); // ambiguous
	d.Derived1::bar();
	d.Derived2::bar();

	auto pBase = static_cast<Base*>(&d); // ambiguous
	auto pBase1 = static_cast<Base>(static_cast<Derived1>(&d));
	auto pBase2 = static_cast<Base>(static_cast<Derived2>(&d));

	auto pD12 = static_cast<Derived12*>(pBase); // ambiguous
	auto pD12_1 = static_cast<Derived12>(static_cast<Derived1>(pBase);
	auto pD12_2 = static_cast<Derived12>(static_cast<Derived1>(pBase);

	struct Base {
	virtual void bar() = 0;
	};
	struct Derived1 : Base { };
	struct Derived2 : Base { };
	struct Derived12 : Derived1, Derived2 {
	virtual void bar() override {
	std::cout << "d12\n";
	}
	};

	Derived12 d;

	auto pDerived1 = static_cast<Derived1*>(&d);
	auto pDerived2 = static_cast<Derived2*>(&d);

	auto pBase1 = static_cast<Base*>(pDerived1);
	auto pBase2 = static_cast<Base*>(pDerived2);

	pDerived1->bar(); // ok
	pDerived2->bar(); // ok
	pBase1->bar(); // ok
	pBase2->bar(); // ok

	struct Base {
	virtual void bar() = 0;
	};
	struct Derived1 : virtual Base { }; // instrusive
	struct Derived2 : virtual Base { }; // instrusive
	struct Derived12 : Derived1, Derived2 {
	virtual void bar() override {
	std::cout << "d12\n";
	}
	};

	Derived12 d12;

	Derived1* pd1 = &d12;
	Derived2* pd2 = &d12;
	Base* pb = &d12;

	auto pd12_1 = static_cast<Derived12*>(pd1); // ok
	auto pd12_2 = static_cast<Derived12*>(pd1); // ok
	auto pd12_3 = static_cast<Derived12*>(pb); // no, why??..