warum ist Polymorphismus nur bei Referenzen und Zeigern möglich?

Ist allerdings nur eine Faustregel, man kann Polymorphismus auch ohne Referenzen/Smartpointer machen.

Wenn das abgeleitete Objekt größer ist, kann es nicht in dem vom Compiler reservierten Speicher für das Basisklassenobjekt untergebracht werden

Falsch, der Compiler macht das ohne zu meckern. Und das Problem tritt auch auf, wenn das abgeleitete Objekt gleich viel/weniger Speicher als die Basisklasse benötigt.

edit: Zum Slicing:

Derived d;
Base b(d);  // Slicing

b ist ein Objekt vom Typ Base, es wird über den Kopierkonstruktor von Base erzeugt. Mit der Größe der Objekte hat das überhaupt nichts zu tun.

struct A {
  A(int a=0) : a(a) {}
  int a;
};

struct B : A {
  B() : A(1), b(1) {}
  int b;
};

void f(A a) { std::cout << a.a << '\n'; }

int main()
{
  B b;
  f(b);
}

Die Frage ergibt für mich keinen Sinn. Ich würde gerne mal ein Programm sehen, das sich nicht so verhält wie erwartet, weil Polymorphismus angeblich nur mit Pointern/Referenzen funktioniert.

code

was erwartet man?
ok als erfahrener erwartet man genau die ausgabe

aber als anfänger denkt man, es kommt immer B raus

Die Frage ergibt für mich keinen Sinn. Ich würde gerne mal ein Programm sehen, das sich nicht so verhält wie erwartet, weil Polymorphismus angeblich nur mit Pointern/Referenzen funktioniert.

Hier ein Beispiel für meine Frage. Warum ist es nicht möglich, polymorphes Verhalten an der Stelle (1) zu haben? Bei einer Referenz (2) sag ich ja auch, dass der statische Typ B& ist und trotzdem wird der dynamische Typ verwendet, nämlich der Typ, auf den die Referenz tatsächlich verweist.
Warum ist das nicht auch an der Stelle (1) möglich? Weil dadurch immer der Copy CTOR/operator= aufgerufen wird, und somit der Typ bei einer Variable vom Typ B immer B ist und niemals D sein kann?

struct B
{
    virtual void print()
    {
        cout<<"Base"<<endl;
    }
};

struct D : public B
{
    virtual void print()
    {
        cout<<"Derived"<<endl;
    }
};

int main()
{

    B b;
    D d;

    // Variablen von Typ B (1)
    B vb=b;
    B vd=d;

    vb.print(); //-> Base
    vd.print(); //-> Base

    // Variablen vom Typ B& (2)
    B& rb=b;
    B& rd=d;

    rb.print(); //-> Base
    rd.print(); //-> Derived

    return 0;
}

Weil dadurch immer der Copy CTOR/operator= aufgerufen wird, und somit der Typ bei einer Variable vom Typ B immer B ist und niemals D sein kann?

Ja.

Eine Referenz oder ein Zeiger verweisen auf ein Objekt. Die Referenz oder der Zeiger weiß, dass das referenzierte Objekt vom Typ B ist. Und eine Instanz der abgeleiteten Klasse D ist ja auch vom Typ B, da es davon abgeleitet ist.