Im Destruktor wird delete für die Kinder aufgerufen.

class Node
{
    std::list< Node* > next;
    ~Node()
    {  
        foreach next
        { 
            delete next;
            erase from list(next);
        }
    }
    void addNode(Node* n)
    {
        next.push_back(n);
    }
}

was macht delete hier genau? nur den destruktor aufrufen oder auch speicher freigeben?

Was ist wenn das ganze folgendermaßen bedient würde:

int main()
{
    Node* root = new Node();
    Node y;
    root.add(&y);
    delete root;
    return 0;
}

würde das Probleme machen?

Und wenn ja wie kann ich sichergehen dass von meiner Klasse nur Zeiger mittels new erstellt werden können?
Privater Konstruktor und Erzeugerklasse?

was macht delete hier genau? nur den destruktor aufrufen oder auch speicher freigeben?

delete zerstört das Objekt. Und da wird der Destruktor aufgerufen, sowie der Speicher freigegeben.

Üblicherweise fügst du keine Knoten direkt ein, sondern übergibst einen Wert, oder was auch immer, welcher gespeichert werden soll. Und die Liste erzeugt dann den Knoten und fügt das übergebene Element dort an. Und gibt dann auch wieder den Speicher für den Knoten frei.

Und ja das, was du da hast gibt dir undefiniertes Verhalten. Wahrscheinlich kriegst du einen Laufzeitfehler.

Node x nicht haben möchte sondern stets einen Aufruf von new haben möchte...

auf die Variante mit nur Werten übergeben möchte ich eigentlich verzichten , da ich intern evt Knoten verschieben können möchte.
Gibt es eine bessere3 Idee?

auf die Variante mit nur Werten übergeben möchte ich eigentlich verzichten , da ich intern evt Knoten verschieben können möchte.
Gibt es eine bessere3 Idee?

Das kannst du auch, wenn du nur Werte übergibst.

Ich versteh eh nicht ganz, was das ganze bei dir soll. Du verwaltest eine Liste von Knotenin einer std::list?! - Macht imo wenig Sinn.

Aber wenn du das wirklich so in etwa brauchst kannst du schon den Konstruktor für Node private machen und dann eine statische Erzeuger Methode anbieten.

class Node
{
//...
  static Node* create () { return new Node; }
private:
  Node (){/*whatever*/}
}

Da musst du aber aufpassen, dass du den Speicher für frei gibst, denn das ist jetzt die Aufgabe von Node, da der Aufrufer das Objekt nicht freigeben sollen muss.