ich habe ein "template-struct" welches einen statischen Member besitzt, allerdings habe ich ein Problem bei der Definition Selbiges.

..\linkedlist\main.cpp(20) : error C2955: 'linkedlist::node' : use of class template requires template argument list
        ..\linkedlist\main.cpp(7) : see declaration of 'linkedlist::node'

#include <iostream>

namespace linkedlist
{
template <typename T>
struct node
{
    T val;
    node *next;
    static node *prev;

    node(): val(0), next(0) {}
    node(T v): val(v), next(0) {
        if (prev != 0)
            prev->next = this;
        prev = this;
    }
};
template <typename T>
node *node<T>::prev = 0;
}

int main()
{
    using namespace linkedlist;
    node x('S');
    node y('R');
    node z('1');
    for (;; x = *x.next) {
        std::cout << x.val;
        if (!x.next) break;
    }
    return 0;
}

Vielen Dank schonmal im Voraus!

Davon abgesehen, warum sollte der Vorgänger eines Knotens einer verketteten Liste statisch sein?!

node<T> *node::prev = 0;

umgeändert, bekomme aber immernoch den selben Fehler...

Die Liste ist nur einfach verkettet, deshalb muss ich nur auf den Vorgänger zugreifen, um dessen next-Member verändern zu können.

statisch heist: egal wie viele objekte vom typ node du hast, egal wie die aussehen, es gibt nur eine variable prev die auf das gleiche zeigt, in dem fall für alle nodes die erzeugt sind. das heist also, alle hätten den gleichen vorgänger...

und da das nicht das ist was du willst, entfernst du das static und hast auch kein problem mehr mit der definition desselben...

Hmmm ich glaube du hast mich falsch verstanden. Die Liste ist nur einfach verkettet. Ich will die Liste nicht von hinten nach vorne durchwandern können. Ich brauche die Adresse des Vorgängers nur, um dessen next-Member auf den neuen Node zeigen zu lassen.

Ich glaube Du hast "statisch" falsch verstanden: Es gibt nur ein "prev" im gesamten Programm. Das heißt jedes Element Deiner Liste hätte denselben Vorgänger. Und irgendein Element Deiner Liste wäre der Vorgänger von allen anderen Elementen.

und wenn du 2 zeiger für prev und next haben willst, hast du eh eine doppelt verkettete liste. aber statisch hat in jedem fall nix da zu suchen.

wie jaxom schon sagte, guck dir nochmal die semantik von static an...

Ich glaube Du hast "statisch" falsch verstanden: Es gibt nur ein "prev" im gesamten Programm.

Das ist mir schon klar.

LordJaxom schrieb:

Das heißt jedes Element Deiner Liste hätte denselben Vorgänger. Und irgendein Element Deiner Liste wäre der Vorgänger von allen anderen Elementen.

Wie gesagt, ich brauche prev nur, um die Adresse des Vorgängers zu speichern, damit ich nochmal beim Erzeugen des nächsten Nodes drauf zugreifen kann. Dass der beim nächsten Node wieder überschrieben wird, ist von mir gewünscht.
Genausogut hätte ich können eine globale Variable nehmen oder den Vorgängernode dem Konstruktor übergeben können.

Zum Problem:
"node" kommt in der Definition zweimal vor. Beide Vorkommen sind Templates. Also müssen bei beiden Vorkommen Templateargumente angegeben werden, um einen Typen zu erhalten.

Ok, verstanden. Wenn auch sehr sehr unüblich. Aber Dir ist auch bewusst, dass Du Dir damit die Möglichkeit verbaust, mehr als eine Liste zu verwalten?

Im Prinzip gings mir nur darum, ein bisschen "static zu üben" :D.

LordJaxom schrieb:

Zum Problem:
"node" kommt in der Definition zweimal vor. Beide Vorkommen sind Templates. Also müssen bei beiden Vorkommen Templateargumente angegeben werden, um einen Typen zu erhalten.

Also so?:

template <typename T>
node<T> *node<T>::prev = 0;

Leider kommt da wieder der selbe Fehler

Es gibt noch mehr Vorkommen von node ohne Templateargumentliste in deinem Code. Schau dir mal Zeile 9 und 10 an.

Das ist dort aber kein Fehler.

#include <iostream>
#include <vector>

namespace linkedlist
{
template <typename T>
struct node
{
    T val;
    node *next;
    static node *prev;

    node(): val(0), next(0) {}
    node(T v): val(v), next(0) {
        if (prev != 0)
            prev->next = this;
        prev = this;
    }
};
template <typename T>
node *node<T>::prev = 0;

}

int main()
{
    using namespace linkedlist;
    node<char> x('S');
    node<char> y('R');
    node<char> z('1');
    for (;; x = *x.next) {
        std::cout << x.val;
        if (!x.next) break;
    }
    return 0;
}

Funktioniert aber nicht

EDIT: Es muss irgendwie am Pointer liegen. Wenn ich ein normales static node deklariere, kann ich es auch definieren.

template <typename T>
struct node
{
    T val;
    node *next;
    static node<T> *prev;

    node(): val(0), next(0) {}
    node(T v): val(v), next(0) {
        if (prev != 0)
            prev->next = this;
        prev = this;
    }
};
template <typename T> node<T> *node<T>::prev = 0;

Funktioniert.

Das Problem hat sich erledigt.

Wundert mich - dass es vorher nicht funktioniert haben soll. Ist nämlich der selbe Code (der Zeilenumbruch ist wurscht).

Zum "static üben" solltest du ein Übungsbeispiel verwenden, wo static sinn macht. In deinem Fall macht es keinen Sinn und führt spätestens bei mehreren Threads zu fehlerhaftem Verhalten.