#include <iostream>
using namespace std;

class Vater 
{
  public: 
    virtual void virt_function() { cout << "Vater" << endl; }; 
};

class Kind : public Vater 
{
  public: 
    virtual void virt_function() { cout << "Kind" << endl; };      
};

void f(Vater* base)    {base->virt_function();}   
void g(Kind*  derived) {derived->virt_function();}

int main()
{
  Vater base;
  Kind  derived;

  f(&base);    //erlaubt! Keine Umwandlung.
  f(&derived); //erlaubt! derived kann in base umgewandelt werden (impliziter Upcast)

  g(dynamic_cast<Kind*>(&base));    //???
  g(&derived); //erlaubt! Keine Umwandlung.
}

nimmt man static_cast<Kind*> läuft das problemlos.

Die Zeile kann nicht funktionieren, weil ein Vater nicht in sein Kind umgewandelt werden kann, dazu fehlen ihm die nötigen Informationen.
Sagen wir, du fügst dem Kind noch eine Membervariable hinzu. Was soll jetzt der Vater machen, der sich auf einmal als Kind ausgeben soll, aber gar nichts von der Membervariablen weiß? Wenn du darauf einen static_cast anwendest und der zufälligerweise funktioniert, dann bist du denke ich trotzdem im undefinierten Verhalten.

Vater* v = new Kind;

hast, dann solltest du den dynamic_cast verwenden.

g(dynamic_cast<Kind*>(v)); // Falls v auf ein Kind zeigt, wird ein Kind an g() übergeben, andernfalls der NULL-Zeiger.

Wie KPC bereits bemerkt hat, ist dies allerdings bei dir nicht der Fall..

Gruß, Caipi