Reversierung mit Rekursion verlinkte Liste, STL

Question

-Code unter Verwendung für mit Rekursion verlinkte Liste Rückwärts fahren, mit STL

  #include<iostream> 
#include<conio.h> 
#include<list> 
using namespace std; 
template<typename T> 
class node 
{ 
public: 
    T data; 
    node<T> *next; 
    node(){ next = NULL; } 
    node(const T& item, node<T> *nextnode = NULL) 
    { 
     data = item; 
     next = nextnode; 
    } 
}; 
template<typename T> 
class Reverse_list 
{ 
private: 
    node<T> *head; 
    void reverse(node<T> *front); 
public: 
    Reverse_list(){ head = NULL; } 
    //template<typename T> 
    void Reverse(); 
    template<typename T> 
    void Display(list<T>& alist); 
}; 


int main() 
{ 
    Reverse_list <int> rl; 
    list<int> intlist; 
    int size, no; 
    cout << "Size of List ?? "; 
    cin >> size; 
    for (int i = 1; i <= size; i++) 
    { 
     cout << "Enter the " << i <<" "<< "element"; 
     cin >> no; 
     intlist.push_front(no); 
    } 


    rl.Display(intlist); 

    rl.Reverse(); 
    rl.Display(intlist); 
    _getch(); 
    return 0; 

} 

template<typename T> 
void Reverse_list<T>::Display(list<T>& alist) 
{ 
    list<int>::iterator iter = alist.begin(); 
    while (iter != alist.end()) 
    { 
     cout << *iter << " "; 
     iter++; 
    } 
} 

template<typename T> 
void Reverse_list<T>::reverse(node<T> *front) 
{ 
    if (front->next == NULL) 
    { 
     head = front; 
     return; 
    } 
    reverse(front->next); 
    node<int> *back = front->next; 
    back->next = front; 
    front->next = NULL; 
} 
template<typename T> 
void Reverse_list<T>::Reverse() 
{ 
    reverse(head); 
} 

Der obige Code erzeugt zwei Fehler.

Fehler 1) Keine Instanz der Funktionsvorlage entspricht der Argumentliste. (Keine Fehlernummer.)

Wenn ich Zeile 1 (erwähnt in einem Code) entferne, dann ist der obige Fehler nicht mehr. (Warum?)

Fehler 2) C2783: 'Leere Reverse_list :: Reverse1 (void)': konnte nicht Template-Argument für 'T'

ableiten Wie oben Fehler zu lösen.

Im obigen Programm, I wollte "head" node (die privat ist) passieren, wie
Argumentfunktion umkehrt. Aber wir können nicht auf private Mitglieder außerhalb der Klasse zugreifen. Also passierte ich indirekt. Ist das ein richtiger Weg? Oder gibt es eine andere Möglichkeit, auf private Daten zuzugreifen?

Answer 1

Ich bin nicht sicher, Ihre Absichten zu verstehen, aber ...

Sie versuchen, eine Methode (reverse()) in einem anderen Verfahren (Reverse()) zu erklären? Uhmmm ....

Wir kommen später darauf zurück.

Stellen Sie sich vor, dass die folgende Anweisung richtige Anweisung von Reverse_list<T>::Reverse()

node<T> *back = front->next; 

ist, warum Sie back als Zeiger auf eine generische Node<T> erklären, wenn Sie front->next zuweisen (so eine bestimmte Node<int>), um es?

Wenn Sie back als node<int> Zeiger, wobei das Verfahren definieren Reverse() nicht mehr Grund hat eine Schablone (abhängig von T) Methode. Und Sie können beide Fehler vermeiden.

Mit Ihrem aktuellen Code, wenn Sie

rl.Reverse(); 

rufen rufen Sie eine Vorlage Methode, aber der Compiler nicht weiß, wie die Art T zu bestimmen. Sie könnten explizit auf diese Weise

rl.Reverse<int>(); 

aber, wie schon geschrieben, ich thik es besser ist, wenn Sie die ganze Vorlage Teil entfernen.

Oder alternativ können Sie die gesamte Klasse in eine Vorlagenklasse transformieren; wo head ist ein Zeiger auf eine generische Node<T>, keine specifica Node<int>.

So etwas (wenn ich das richtig, Ihre Absichten zu verstehen)

template <typename T> 
class Reverse_list 
{ 
    private: 
     node<T> *head; 

     void reverse (node<T> * front); 

    public: 
     Reverse_list() : head(NULL) 
     { } 

     void Reverse(); 
     void Display(list<T>& alist); 
}; 

template<typename T> 
void Reverse_list<T>::reverse (node<T> * front) 
{ 
    if (front->next == NULL) 
    { 
     head = front; 
     return; 
    } 
    reverse(front->next); 
    node<T> *back = front->next; 
    back->next = front; 
    front->next = NULL; 
} 

template<typename T> 
void Reverse_list<T>::Reverse() 
{ reverse(head); } 

In diesem Fall in main(), rl sollte als

Reverse_list<int> rl; 

Befestigungs T als int, und der Aufruf von Reverse() deklariert werden sollte

sein

rl.Reverse(); 

--- EDIT 2016.05.10 ---

Mit der "Template Reverse_list" Lösung, sollten Sie drei Punkte (zuletzt) ​​korrigieren.

1) in Reverse_list Klassendeklaration haben Sie die Zeile template<typename T> vor void Reverse() kommentiert; gut; Sie sollten die gleiche Zeile (aus dem gleichen Grund) löschen (kommentieren), bevor void Display(list<T>& alist);; so wird die Klasse

template<typename T> 
class Reverse_list 
{ 
private: 
    node<T> *head; 
    void reverse(node<T> *front); 
public: 
    Reverse_list(){ head = NULL; } 
    //template<typename T> 
    void Reverse(); 
    //template<typename T> 
    void Display(list<T>& alist); 
}; 

2) Display() nun ein Verfahren einer Templat-Klasse ist; so dass die Linie

list<int>::iterator iter = alist.begin(); 

werden

list<T>::iterator iter = alist.begin(); 

3) reverse() nun ein Verfahren einer Templat-Klasse ist; so dass die Linie

node<int> *back = front->next; 

werden

node<T> *back = front->next;