C++ каст при передаче по ссылке

#include <cstdio>

struct Lol { 
   int a;
   int c;

   virtual ~Lol() {}
};

template<class Derived>
struct Foo {
   int d;
   int e;
   int f;
   
   virtual void test()
   {
      printf("this obj:   %x\n"
             "derived(1): %x\n"
             "derived(2): %x\n",
             this,
             static_cast<Derived * const>(this),
             dynamic_cast<Derived * const>(this));
   }
};

struct Bar: public Foo<Bar>, public Lol {};
struct Baz: public Lol, public Foo<Baz> {};

int main (int argc, char *argv[]) {
   Bar bar;
   Baz baz;

   printf("bar: %x\n", &bar);
   bar.test();

   printf("baz: %x\n", &baz);
   baz.test();

   printf("pointer test\n");
   Foo<Baz> *pFoo = &baz;
   printf("pFoo:       %x\n"
          "derived(1): %x\n"
          "derived(2): %x\n",
          pFoo,
          static_cast<Baz*>(pFoo),
          dynamic_cast<Baz*>(pFoo));
   return 0;
}

/tmp $ ./a.out 
bar: 5603c5e0
this obj:   5603c5e0
derived(1): 5603c5e0
derived(2): 5603c5e0
baz: 5603c610
this obj:   5603c620
derived(1): 5603c610
derived(2): 5603c610
pointer test
pFoo:       5603c620
derived(1): 5603c610
derived(2): 5603c610

#include <iostream>

template <typename T>
class Base {
protected: // !!!
	Base() = default;
	Base(const Base&) = default;
public:
	int getX() const {
		return static_cast<T const*>(this)->x;
	}
};

class Derived : public Base<Derived> {
public:
	int x = 5;
};


template <typename T>
void foo(const Base<T>& a) {
	std::cout << a.getX() << std::endl;
}

int main() {
	Derived a;
	foo(a); 
	
	// clang не компилирует, говорит что конструктор protected, gcc так не думает
	Base<Derived> b;
	foo(b);
	
	// и clang, и gcc не компилируют
	Base<Derived> c = b;
	
	return 0;
}

struct Foo {
};

struct A: public Base<Foo> {
    int x;
};
...

Base<A> b;
foo(b);

struct Super : public Base<Derived> {
    int y = 10;
    int x = 15;
};

// . . .

Super c;
foo(c);
// выводит внезапно 10, или что там в Super по смещению Derived::x

#include <iostream>

class A {
protected:
	A() = default;
//	virtual void foo() {}
};

int main() {
	A g;
	
	return 0;
}

#include <iostream>

//
// Исходные определения
//

template <typename T>
struct Base
{
    int getX() const
    {
        return static_cast<const T*>(this)->x;
    }
};

struct Derived : public Base<Derived>
{
    int x = 5;
};

struct Super : public Base<Derived>
{
    int y = 10;
    int x = 15;
};

//
// Compile-time проверка на наследование
//

template <typename Base, typename Derived>
struct inherits_from
{
    typedef char (&yes)[1];
    typedef char  (&no)[2];

    struct check
    {
        operator Base*() const;
        operator Derived*();
    };

    template <typename T>
    static yes really(Derived*, T);
    static no  really(Base*,  int);

    static const bool value = sizeof(really(check(), int())) == sizeof(yes);
};

//
// Compile-time проверка на идентичность типов
//

template <typename A, typename B>
struct equal_types
{
    static const bool value = false;
};

template <typename T>
struct equal_types<T, T>
{
    static const bool value = true;
};

//
// Собсно код
//

template <typename T>
void foo(const T& arg)
{
    static_assert(inherits_from<Base<T>, T>::value
            and not equal_types<Base<T>, T>::value,
        "Expected arg to be of type T inherited from Base<T>");

    std::cout << arg.getX() << std::endl;
}

int main()
{
    foo(Derived());         //  5

    foo(Base<Derived>());   //  ошибка компиляции

    foo(Super());           //  ошибка компиляции
}

struct Derived2: public Derived { };
...
    foo(Derived2( ));

// фактически в памяти последовательно расположенны члены Derived и Base<Derived>
// this внутри getX указывает на начало Base, 
// внутри getX, this кастуется к Derived*, полученный указатель указывает на начало Derived
Derived a;
a.getX();

// тоже самое, но в памяти только Base<Derived>, если кастануть this к Derived*, 
// то полученный указатель будет указывать на мусор рядом с Base<Derived>, что и происходит
Base<Derived> b;
b.getX();