Dann wollt ich eine Funktion schreiben die mir ein Objekt von einem der 3en erstellt:

node* make_node(int type, int name)
{
    if(type == 1)
        return new stadt_node(name);
    else if(type == 2)
        return new dorf_node(name);
    else if(type == 3)
        return new raststaette_node(name);
    else
        return NULL;               
}

Warum geht das nicht? Fehlermeldung siehe Titel.

Ich hatte auch probiert dies als statische Methode in die Oberklasse node zu packen. Aber da sind die Unterklassen ja noch nicht deklariert, wie mach ich das nochmal?

PS: Übrigens kannst du eine Mthode auch erst nach der Klassendefinition anlegen:

class node
{
publi:
  static node* make_node(int type, int name);
};

class stadt_node : public node
{
};
...

node* node::make_node(int type,int name)
{
...
}

Ja thx das wars, natürlich ist die Funktion danach deklariert.
Wie "deklariere" ich denn die 3 Unterklassen vor der Oberklasse das ich meine make_node Funktion als static Methode in die Oberklasse packen kann?

Gar nicht, wozu auch?

Danke nochmal für die Tipps eine Frage ist noch offen:

Nehmen wir mal an ich möchte die Funktion aber als static in die node Klasse packen also...:

class foo
{
static void bla() { .... new special_foo() }
};

class special_foo : public foo
{
...
};

Dafür gabs doch wenn ich mich recht entsinne eine Art "Namedeklaration" damit das geht oder?

//foo.h
#ifndef _FOO_H_
#define _FOO_H_

class foo
{
   static foo* bla();
};

class special_foo : public foo
{
...
};

#endif

//foo.cpp
#include "foo.h"

foo* foo::bla() { .... new special_foo() }

Aber wie gesagt, ich würd das trennen. Mach ne weitere Klasse

//ungetestet und unvollständig!!

#include <memory>  //für auto_ptr

class FooFactory
{
public:
    std::auto_ptr<Foo> create_foo() { ...return std::auto_ptr<Foo>( new special_foo() ) }
//...
};

Und auto_ptr verringert hier die Gefahr ein Speicherleck durch fehlendes delete beim Aufrufer zu erzeugen

Es geht jedenfalls nicht, wenn du Kopf und Implementation nicht trennst.

Die Lösung wurde ja bereits genannt: Erst die Oberklasse definieren, dann die Unterklassen, dann die Methode der Oberklasse, welche die Unterklassen erzeugen muss.

Was ist denn wenn man die static Methode inline macht? Dann ist nichts mehr mit außerhalb definieren? Da muss es einfach eine Möglichkeit geben

class Abc;

Richtig. Eine Forwarddeklaration. Wurde ja bereits genannt. Reicht nicht um ein Objekt zu erzeugen, dazu muss mindestens die Größe bekannt sein (von der Verfügkarbeit von Konstruktoren ganz zu schweigen).

Was ist denn wenn man die static Methode inline macht? Dann ist nichts mehr mit außerhalb definieren.

Doch, mit dem Schlüsselwort "inline"