Sortiertemplate (spezifisch für strings)



  • Hi,
    ich komme seit stunden nicht bei meiner aufgabe weiter und finde auch nicht den fehler bzw wie ich richtig stellen kann, was ich falsch gemacht habe.
    Mein aufgabe: das programm soll parameter einlesen und in einer liste speichern.
    Die einträge in der Liste sollen dann auf- oder absteigend sortiert
    (durch Vergleich von strings mittels < bzw. >) und anschließend wieder
    ausgegeben.

    mein hauptprogramm (schon vorgegeben):
    #include <iostream>

    #include <string>

    using namespace std;

    #include "1.h"

    #include "2.h"

    int main(int argc, char* argv[])

    { TListenKnoten<string> *anker = nullptr;

    for (int i = 1; i < argc; i++)
    hinten_anfuegen<string>(anker, argv[i]);

    if (string(argv[0]) == "auf.exe")
    sortiere<TListenKnoten<string>, string>(anker,&aufsteigend<string>); //Aufruf der Sortierfunktion (aufsteigende Sortierung)

    else if (string(argv[0]) == "ab.exe")
    sortiere<TListenKnoten<string>, string>(anker, //Aufruf der Sortierfunktion (absteigende Sortierung)
    &absteigend<string>);

    else
    {
    std::system("PAUSE"); return 1;
    }

    liste_ausgeben<string>(anker);

    std::system("PAUSE");
    return 0;
    }
    ________________________________________________________
    //1.h : erstellen und ausgeben der liste

    #pragma once

    template <typename T> struct TListenKnoten
    {
    T data;
    TListenKnoten<T> *next;
    };

    template <typename T> void hinten_anfuegen(TListenKnoten<T>* &anker, T wert)
    { TListenKnoten<T> *neuer_eintrag = new TListenKnoten<T>;
    neuer_eintrag->data = wert;
    neuer_eintrag->next = 0;

    if (anker == nullptr)
    anker = neuer_eintrag;

    else
    {
    TListenKnoten<T> *ptr = anker;

    while (ptr->next != nullptr)
    ptr = ptr->next;
    ptr->next = neuer_eintrag;
    }
    }

    template void hinten_anfuegen<string>(TListenKnoten<string> * &anker, string wert); //Instanziierung (für string)

    template <typename T> void liste_ausgeben(TListenKnoten<T> *anker)

    { if (anker == nullptr)
    cout << "Leere Liste." << endl;

    else
    {
    cout << "[ ";

    TListenKnoten<T> *ptr = anker;

    do
    {
    cout << ptr->data;
    if (ptr->next != nullptr) cout << " , ";
    else cout << " ";
    ptr = ptr->next;
    } while (ptr != nullptr);
    cout << "]" << endl;
    }
    }

    template void liste_ausgeben<string>(TListenKnoten<string> *anker);

    _______________________________________________________________
    //2.h: sortierfunktionen

    #pragma once

    template <typename T> void aufsteigend(T &x, T &y) //Übung
    {
    if (x > y) //Werte von x und y tauschen falls...
    {
    T temp = x;
    x = y;
    y = temp;
    }
    }
    template void aufsteigend <string>(string&x, string &y); //Instanziierung

    template <typename T> void absteigend(T &x, T &y) //Übung
    {
    if (x < y) //Werte von x und y tauschen falls...
    {
    T temp = x;
    x = y;
    y = temp;
    }
    }
    template void absteigend <string>(string&x, string &y); //Instanziierung

    template <typename T1, typename T2> void sortiere(T1 *anker, void(*cmp_p)(T2 &, T2 &))
    {
    T1 *ptr = anker;

    int anzahl_an_strings = 0; //wieviel strings gibt es in der Liste?

    while (ptr->next != nullptr)
    {
    anzahl_an_strings++;
    ptr = ptr->next; //Es wird durch die Liste gelaufen
    }

    ptr = anker; //Pointer wird wieder auf den Anfang der Liste gesetzt

    for (int i = 0; i <= anzahl_an_strings; i++) //i=Vergleichsrunde(n); es wird solange verglichen bis keine strings mehr übrig sind
    {
    while (ptr->next != nullptr) //bis zum Ende der Liste (Next-pointer des letzten Elements entspricht dem Nullpointer)
    {
    ptr = ptr->next;
    cmp_p(ptr->data, ptr->next->data); //Vergleichsfunktion wird aufgerufen
    }

    }
    }

    template void sortiere <string>(string *anker, void(*cm_p)(string&, string&)); //Instanziierung

    _____________________________________________________________

    Ich bin noch ganz neu beim programmieren und kenne mich leider wenig aus!

    der angezeigte fehler ist, warum die weitere compilierung abgebrochen wird:
    Fehler 1 error C2039: 'next': Ist kein Element von 'std::basic_string<char,std::char_traits<char>,std::allocator<char>>
    bei der sortierfunktion!

    Ich hoffe ich finde hier Hilfe!
    Danke schonmal für antworten



  • Ich bin noch ganz neu beim programmieren und kenne mich leider wenig aus!

    der angezeigte fehler ist, warum die weitere compilierung abgebrochen wird:
    Fehler 1 error C2039: 'next': Ist kein Element von 'std::basic_string<char,std::char_traits<char>,std::allocator<char>>
    bei der sortierfunktion!

    hast du den code selbst geschrieben?
    verstehst du was du da machst? bzw. machen willst?

    zu deiner frage:
    die von dir beschriebene fehlermeldung hört sich für mich spontan nach einem falschen datentyp in einer funktion oder sowas an...
    welche zeile gehört dazu?
    kannst du den code bitte nochmal in code-tags posten...?-> dann kann ich dir auch genau sagen wo es schief geht... 🙂 (ist sehr schlecht so zu lesen...)

    hinweis:
    zum sortieren gibt es verschiedene sortier-algorithmen(quicksort, bubblesort...) ...
    die sind eig nicht kompliziert zu verstehen (bzw. nimm einfach einen einfacheren...) und sind eig genau für sowas gemacht... 🙄
    oder ist es teil deiner aufgabe das selbst zu coden?

    lg



  • also hauptprogramm war so vorgegeben (also hab ich nicht selbst geschrieben abgesehen von den kommentarzeilen), die funktion zum erstellen und ausgeben der liste war auch vorgegeben zum teil (man musste es nur zu einem template verändern und spezifisch instanziieren)!
    Ich habe vorallem beim sortier-teil schwierigkeiten (den hab ich auch selbstgeschrieben 😕 😃 😞 ):

    #pragma once

    template <typename T> void aufsteigend(T &x, T &y)
    { if (x > y) //Werte von x und y tauschen falls...
    {
    T temp = x;
    x = y;
    y = temp;
    }
    }
    template void aufsteigend <string>(string&x, string &y); //Instanziierung

    template <typename T> void absteigend(T &x, T &y)
    {
    if (x < y) //Werte von x und y tauschen falls...
    {
    T temp = x;
    x = y;
    y = temp;
    }
    }
    template void absteigend <string>(string&x, string &y); //Instanziierung

    template <typename T1, typename T2> void sortiere(T1 *anker, void(*cmp_p)(T2 &, T2 &))
    {
    T1 *ptr = anker;

    int anzahl_an_strings = 0; //wieviel strings gibt es in der Liste?

    while (ptr->next != nullptr)
    {
    anzahl_an_strings++;
    ptr = ptr->next; //Es wird durch die Liste gelaufen
    }

    ptr = anker; //Pointer wird wieder auf den Anfang der Liste gesetzt

    for (int i = 0; i <= anzahl_an_strings; i++)
    //i=Vergleichsrunde(n); es wird solange verglichen bis keine strings mehr übrig //sind
    { while (ptr->next != nullptr)
    //bis zum Ende der Liste
    //(Next-pointer des letzten Elements entspricht dem Nullpointer)
    {
    ptr = ptr->next;
    cmp_p(ptr->data, ptr->next->data); //Vergleichsfunktion wird aufgerufen
    }
    }

    }

    template void sortiere <string>(string *anker, void(*cm_p)(string&, string&)); //Instanziierung

    Die teile mit auf- bzw absteigend waren (in einem anderem Kontext) schon so vorgegeben und man musste sie bloß instanziieren!
    Zu denen habe ich bloß die Frage: die strings werden hier doch nur nacheinander verglichen und wenn es dazu kommt dass das nächste größer ist als das vorherige sollen diese vertauscht werden, oder?

    die eigentliche sortierfunktion hab ich komplett selbst erstellt!
    und dadrin liegt natürlich wahrscheinlich auch der größte fehler 😞 🙄



  • die fehler-meldung wurde zur zeile:
    "while (ptr->next != nullptr)" angezeigt!

    (in der sortierfunktion)



  • also hauptprogramm war so vorgegeben (also hab ich nicht selbst geschrieben abgesehen von den kommentarzeilen), die funktion zum erstellen und ausgeben der liste war auch vorgegeben zum teil (man musste es nur zu einem template verändern und spezifisch instanziieren)!
    Ich habe vorallem beim sortier-teil schwierigkeiten (den hab ich auch selbstgeschrieben 😕 😃 😞 ):

    ach so... 🙂
    schau dir doch einfach mal die sortier algorithmen an...
    es gibt da eig auch schöne "tutorials" wo das alles erklärt ist...
    hier link:
    http://www.hipphampel.de/?item=cpp/sorting
    http://www.virtual-maxim.de/elementare-sortierverfahren-in-c/

    Die teile mit auf- bzw absteigend waren (in einem anderem Kontext) schon so vorgegeben und man musste sie bloß instanziieren!
    Zu denen habe ich bloß die Frage: die strings werden hier doch nur nacheinander verglichen und wenn es dazu kommt dass das nächste größer ist als das vorherige sollen diese vertauscht werden, oder?

    die eigentliche sortierfunktion hab ich komplett selbst erstellt!
    und dadrin liegt natürlich wahrscheinlich auch der größte fehler 😞 🙄

    -> das vorgehen beim sortieren unterscheidet sich, je nach angewendetem algo...
    (schau die links an ... da wird erklärt wie die jeweils vorgehen... )

    i.wie hat dir was die code-tags "zerstört/aufgehoben" 🙂 ...
    vll kannst du ja das nächste mal vorschau nutzen dann fällt dir sowas vorher auf ... 🙂

    ich sehe so jetzt auf die schnelle nix... hab aber leider keinen debugger gerade am start...
    welche zeile war der fehler? 🙄



  • sry mit der zeile hab ich eben nach dem post erst gesehen... 🙂

    Fehler 1 error C2039: 'next': Ist kein Element von 'std::basic_string<char,std::char_traits<char>,std::allocator<char>>

    i.wie findet er den befehl "next" nicht ...
    sieht so aus wenn es i.wie an "ptr" liegt... 🙄



  • schonmal danke für deine antworten 🙂

    ich schaue mir mal die tutorials an!
    Leider darf ich keine schon "vorgefertigten" algorithemen oder systembefehle benutzen, sondern muss alles selbst coden 😞


  • Mod

    newling987 schrieb:

    Leider darf ich keine schon "vorgefertigten" algorithemen oder systembefehle benutzen, sondern muss alles selbst coden 😞

    Und die Sachen aus den Headern string und iostream zählen nicht dazu?



  • newling987 schrieb:

    schonmal danke für deine antworten 🙂

    ich schaue mir mal die tutorials an!
    Leider darf ich keine schon "vorgefertigten" algorithemen oder systembefehle benutzen, sondern muss alles selbst coden 😞

    ach so... jop...
    die sind ja nicht "vorgefertigt" sondern werden so benutzt, vom reinen vorgehen... 🙂 -> das "feste" prinzip ist ja gerade deren stärke...
    anpassen musst du eh... 😃 -> aufsteigend, absteigend 😃

    ptr hat wahrscheinlich den falschen datentyp... (bzw. zeigt auf den falschen, vll kannst das ja mal eben testen... hab gerade keine ide zur verfügung... ist für mich halt relativ schwierig weil der code ist ohne die tags schlecht zu lesen...)
    aber so wie ich das sehe zeigt wahrscheinlich ptr auf einen falschen datentyp... (evt. std::string?) -> zumindest laut fehlermeldung...
    und wenn ptr ein string ist dann gibts kein "ptr->next"...



  • also ich hab nochmal geschaut...
    weiß nicht genau ob es dieses "ptr-next" wirklich gibt? was soll das sein? eine funktion? ich dachte "next" spring automatisch weiter ... aber i.wie find ich diese funktion nicht... (bzw. bei mir gibts die nicht...)
    das wird dann auch der fehler sein... vll hilft dir das hier...:
    hab das eben gecodet um es zu verdeutlichen...

    #include <iostream>
    #include <string>
    
    int main()
    {
    	struct test
    	{
    	   int test_int_1;
    	   int test_int_2;
    	   int test_int_3;
    	   int test_int_4;
    	   int test_int_5;
    
    	   int array[10]={1,2,3,4,5,6,7,8,9,10};
    	};
    
    	//hier wird die stuktur angelegt und ein pointer auf die werte von "struktur" gesetzt
    	struct test struktur;
    	struct test *ptr = &struktur;
    
    	//werte über den pointer zuweisen
    	ptr->test_int_1 = 5;
    	ptr->test_int_2 = 10;
    	ptr->test_int_5 = 1000000000;
    
    	//hier testen obs geklappt hat... (über pointer den wert abfragen)
    	std::cout <<"1: " << ptr-> test_int_1 << std::endl;
    	std::cout <<"2: " << ptr-> test_int_2 << std::endl;
    	std::cout <<"5: " << ptr-> test_int_5 << std::endl;
    
    	//---------------------------------------------------------------------
    
    	int gr=0;
    	int x=0;
    
    	//hier wird die größe des arrays festgestellt
    	gr=sizeof(ptr->array)/sizeof(int);
    
    	while(x!=gr)
    	{
    		std::cout << ptr->array[x] << std::endl;
    		x++;
    	}
    
    }
    

    also du musst den pointer erst einen wert/bzw. adresse geben... sonst ist "next" kein element von ptr... 😉 wie in der fehler meldung...

    schau oben in mein beispiel da siehst du wie man ptr sofern du es so nennen willst werte gibt 😉 ...

    wenn du das machst sollte der fehler behoben sein 😉 ...

    lg
    hoff das hat dir geholfen...
    sry das es kruz gedauert hat... 🙂



  • so hab das programm jetzt soweit verändert, dass es startet 🙂
    leider werden keine benutzereingabe oder so eingelesen...
    liegt es am programm? (hauptprogramm?)

    also mit vorgefertigt mein ich sowas wie (das gehört jetzt zwar nicht zu DIESEM thema), aber sachen wie, dass automatisch alle buchstaben eines strings in groß oder in kleinbuchstaben umgewandelt werden!
    ___________________________________________________________________________
    Hauptprogramm:
    [code="cpp"]#include <iostream>
    #include <string>

    using namespace std;

    #include "Template.h"
    #include "sortierfunktion.h"

    int main(int argc, char* argv[])

    { TListenKnoten<string> *anker = nullptr;

    for (int i = 1; i < argc; i++)
    hinten_anfuegen<string>(anker, argv[i]);

    if (string(argv[0]) == "auf.exe")
    sortiere<TListenKnoten<string>, string>(anker,&aufsteigend<string>); //Aufruf der Sortierfunktion (aufsteigende Sortierung)

    else if (string(argv[0]) == "ab.exe")
    sortiere<TListenKnoten<string>, string>(anker, //Aufruf der Sortierfunktion (absteigende Sortierung)
    &absteigend<string>);

    else
    {
    std::system("PAUSE"); return 1;
    }

    liste_ausgeben<string>(anker);

    std::system("PAUSE");
    return 0;
    }
    _______________________________________________________________________________
    sortierfunktion:

    #include "Template.h"
    #include <string>

    using namespace std;

    template <typename T> void aufsteigend(T &x, T &y) {

    if (x > y) {
    T temp = x;
    x = y;
    y = temp;
    }

    }
    template void aufsteigend<string>(string &x, string &y);

    template <typename T> void absteigend(T &x, T &y)
    {

    if (x < y) {
    T temp = x;
    x = y;
    y = temp;
    }

    }
    template void absteigend<string>(string &x, string &y);

    template <typename T1, typename T2>
    void sortiere(T1 *anker,
    void(*cmp_p)(T2 &, T2 &))
    {
    T1 *ptr = anker;

    int anzahl_an_strings = 1;
    while (ptr->next != nullptr) //bis zum ende der liste (next-pointer des letzten elements entspricht dem nullpointer)
    {
    anzahl_an_strings++;
    ptr = ptr->next; //es wird durch die Liste gelaufen
    }

    ptr = anker; //Pointer wird wieder auf Anfang der Liste gesetzt

    for (int i = 0; i < anzahl_an_strings; i++) //i=Vergleichsrunden
    {
    cmp_p(ptr->data, ptr->next->data); //Sortierfunktion wird aufgerufen: es wird zwischen dem jetztigen Element
    ptr = ptr->next; //(auf welches der Pointer zeigt) und dem darauffolgendem (->next) verglichen
    }

    }
    template void sortiere<TListenKnoten<string>, string>(TListenKnoten<string> *anker,void(*cmp_p)(string &, string &));

    _______________________________________________________________________________
    Ausgeben und erstellen der Liste (Template.h):

    #pragma once

    template <typename T> struct TListenKnoten
    {
    T data;
    TListenKnoten<T> *next;
    };

    template <typename T> void hinten_anfuegen(TListenKnoten<T>* &anker, T wert)
    {

    TListenKnoten<T> *neuer_eintrag = new TListenKnoten<T>;
    neuer_eintrag->data = wert;
    neuer_eintrag->next = 0;

    if (anker == nullptr)
    anker = neuer_eintrag;

    else
    {
    TListenKnoten<T> *ptr = anker;

    while (ptr->next != nullptr)
    ptr = ptr->next;
    ptr->next = neuer_eintrag;
    }
    }

    template void hinten_anfuegen<string>(TListenKnoten<string> * &anker, string wert); //Instanziierung (für string)

    template <typename T> void liste_ausgeben(TListenKnoten<T> *anker)

    { if (anker == nullptr)
    cout << "Leere Liste." << endl;

    else
    {
    cout << "[ ";

    TListenKnoten<T> *ptr = anker;

    do
    {
    cout << ptr->data;
    if (ptr->next != nullptr) cout << " , ";
    else cout << " ";
    ptr = ptr->next;
    } while (ptr != nullptr);
    cout << "]" << endl;
    }
    }

    template void liste_ausgeben<string>(TListenKnoten<string> *anker);



  • sorry dass es wieder in getippter form ist!
    Ist mein erster beitrag überhaupt hier und sonst in nem c++-forum und weiß nicht genau wies geht 🤡



  • so hab das programm jetzt soweit verändert, dass es startet 🙂
    leider werden keine benutzereingabe oder so eingelesen...
    liegt es am programm? (hauptprogramm?)

    also mit vorgefertigt mein ich sowas wie (das gehört jetzt zwar nicht zu DIESEM thema), aber sachen wie, dass automatisch alle buchstaben eines strings in groß oder in kleinbuchstaben umgewandelt werden!

    👍
    also war das problem das es kein "next" gab?

    zu den benutzereingaben:
    hier ist das interessant:

    int main(int argc, char* argv[])
    

    das sind startparameter deines programms...
    worüber du die nutzereingaben tätigen kannst... (argc = wie viele argumente, argv = welche...)
    also starte dein prog. mal von der konsole/terminal/cmd was auch immer 😃 ...
    mit den richtigen eingaben... also

    (unter windows:)

    programm.exe EINGABE
    

    da musst du nur schauen was du angeben musst und in welcher reihenfolge...
    oder hattest das so gemacht und trozdem wurden keine "nutzereingaben erkannt?"


  • Mod

    newling987 schrieb:

    sorry dass es wieder in getippter form ist!
    Ist mein erster beitrag überhaupt hier und sonst in nem c++-forum und weiß nicht genau wies geht 🤡

    Die Smileys scheinst du doch gefunden zu haben? Guckst du mal etwas tiefer darunter, der Knopf mit "C++" drauf. Drei Methoden:

    • Quelltext markieren, Knopf drücken
    • Cursor an den Anfang des Quelltextes setzen, Knopf einmal drücken. Knopf bekommt ein Sternchen. Cursor ans Ende des Quelltextes setzten, Knopf noch einmal drücken.
    • Von Hand, ganz ohne Knopf [code="cpp"] an den Anfang des Quelltextes schreiben, und [/code] ans Ende.

    Als registrierter Nutzer kannst du deine Beiträge auch nachträglich editieren. Ich schlage vor, dass du dies tun solltest und die passenden Codetags einfügst. Mit der Vorschau kannst du sehen, ob es funktioniert.



  • nee ich hab das template in dem next definiert war nicht inkludiert und auch nicht string!

    ok alles klar dankeschön 🙂

    //Hauptprogramm: 
    #include <iostream> 
    #include <string> 
    
    using namespace std; 
    
    #include "Template.h" 
    #include "sortierfunktion.h" 
    
    int main(int argc, char* argv[]) 
    
    { TListenKnoten<string> *anker = nullptr; 
    
    for (int i = 1; i < argc; i++) 
    hinten_anfuegen<string>(anker, argv[i]); 
    
    if (string(argv[0]) == "auf.exe") 
    sortiere<TListenKnoten<string>, string>(anker,&aufsteigend<string>); //Aufruf der Sortierfunktion (aufsteigende Sortierung) 
    
    else if (string(argv[0]) == "ab.exe") 
    sortiere<TListenKnoten<string>, string>(anker, //Aufruf der Sortierfunktion (absteigende Sortierung) 
    &absteigend<string>); 
    
    else 
    { 
    std::system("PAUSE"); return 1; 
    } 
    
    liste_ausgeben<string>(anker); 
    
    std::system("PAUSE"); 
    return 0; 
    } 
    //_______________________________________________________________________________ 
    //sortierfunktion: 
    
    #include "Template.h" 
    #include <string> 
    
    using namespace std; 
    
    template <typename T> void aufsteigend(T &x, T &y) { 
    
    if (x > y) { 
    T temp = x; 
    x = y; 
    y = temp; 
    } 
    
    } 
    template void aufsteigend<string>(string &x, string &y); 
    
    template <typename T> void absteigend(T &x, T &y) 
    { 
    
    if (x < y) { 
    T temp = x; 
    x = y; 
    y = temp; 
    } 
    
    } 
    template void absteigend<string>(string &x, string &y); 
    
    template <typename T1, typename T2> 
    void sortiere(T1 *anker, 
    void(*cmp_p)(T2 &, T2 &)) 
    { 
    T1 *ptr = anker; 
    
    int anzahl_an_strings = 1; 
    while (ptr->next != nullptr) //bis zum ende der liste (next-pointer des letzten elements entspricht dem nullpointer) 
    { 
    anzahl_an_strings++; 
    ptr = ptr->next; //es wird durch die Liste gelaufen 
    } 
    
    ptr = anker; //Pointer wird wieder auf Anfang der Liste gesetzt 
    
    for (int i = 0; i < anzahl_an_strings; i++) //i=Vergleichsrunden 
    { 
    cmp_p(ptr->data, ptr->next->data); //Sortierfunktion wird aufgerufen: es wird zwischen dem jetztigen Element 
    ptr = ptr->next;	//(auf welches der Pointer zeigt) und dem darauffolgendem (->next) verglichen 
    } 
    
    } 
    template void sortiere<TListenKnoten<string>, string>(TListenKnoten<string> *anker,void(*cmp_p)(string &, string &)); 
    
    //_______________________________________________________________________________ 
    //Ausgeben und erstellen der Liste (Template.h): 
    
    #pragma once 
    
    template <typename T> struct TListenKnoten 
    { 
    T data; 
    TListenKnoten<T> *next; 
    }; 
    
    template <typename T> void hinten_anfuegen(TListenKnoten<T>* &anker, T wert) 
    { 
    
    TListenKnoten<T> *neuer_eintrag = new TListenKnoten<T>; 
    neuer_eintrag->data = wert; 
    neuer_eintrag->next = 0; 
    
    if (anker == nullptr) 
    anker = neuer_eintrag; 
    
    else 
    { 
    TListenKnoten<T> *ptr = anker; 
    
    while (ptr->next != nullptr) 
    ptr = ptr->next; 
    ptr->next = neuer_eintrag; 
    } 
    } 
    
    template void hinten_anfuegen<string>(TListenKnoten<string> * &anker, string wert); //Instanziierung (für string) 
    
    template <typename T> void liste_ausgeben(TListenKnoten<T> *anker) 
    
    {	if (anker == nullptr) 
    cout << "Leere Liste." << endl; 
    
    else 
    { 
    cout << "[ "; 
    
    TListenKnoten<T> *ptr = anker; 
    
    do 
    { 
    cout << ptr->data; 
    if (ptr->next != nullptr) cout << " , "; 
    else cout << " "; 
    ptr = ptr->next; 
    } while (ptr != nullptr); 
    cout << "]" << endl; 
    } 
    } 
    
    template void liste_ausgeben<string>(TListenKnoten<string> *anker);
    


  • gut freut mich wenn ich helfen konnte... 🙂
    viel erfolg noch 😃
    lg



  • Du brauchst Deine Templates nicht überall zu instanziieren. Alles rausschmeissen. Z.B. in template.h :

    template void liste_ausgeben<string>(TListenKnoten<string> *anker);
    

    Dann grübel nochmal über den Kern Deiner Anwendung: das sortieren.
    Warum ermittelst Du erst die Anzahl? könntest Du diesen Schritt nicht komplett einsparen?
    Mit dem Algorithmus scheinst Du etwas kurz zu springen.
    Welchen Algorithmus hast Du überhaupt im Kopf? Ist das auch der Algorithmus, den Du implementiert hast?

    template <typename T1, typename T2>
    void sortiere(T1 *anker, void(*cmp_p)(T2 &, T2 &))
    {
      T1 *ptr = anker;
    
      int anzahl_an_strings = 1;
      while (ptr->next != nullptr)
      {
        anzahl_an_strings++;
        ptr = ptr->next;
      } 
      ptr = anker;
      for (int i = 0; i < anzahl_an_strings; i++)
      {
        cmp_p(ptr->data, ptr->next->data);
        ptr = ptr->next;
      }
    }
    

Anmelden zum Antworten