Warum meckert Code::Blocks "undefined reference"?



  • //header
    #ifndef SORTER_H_
    #define SORTER_H_
    #include <vector>
    #pragma once
    
    namespace sorter
    {
        template<typename T, typename U>
        void sort_func(T &copy_wordlist, U word);
    }
    #endif
    
    //Sortierfunktion
    #include "sorter.h"
    #include <iostream>
    #include <vector>
    using namespace std;
    using namespace sorter;
    
    template<typename T, typename U>
    void sorter::sort_func(T &copy_wordlist, U word)
    {
        vector<std::string> puffer1, puffer2; // 2 Vektoren, in welche die W
        int b, place = 0, j, k=0, m=0;
        string word_puffer, word_puffer2;
    
    
        //Erster Loop ist für den Anfangsbuchstaben des Wortes.
        for(unsigned int i=0; i<copy_wordlist.size(); i++)
        {
            word_puffer = copy_wordlist[i]; //Wort des
    
            if((int)word[0] > (int)word_puffer[0]) //größer
            {
                if(i+1 == copy_wordlist.size())
                {
                    copy_wordlist.push_back(word);
                    break;
                }
                continue;
            }
    
            if((int)word[0] == (int)word_puffer[0]) // gleich
            {
                puffer1.push_back(copy_wordlist[i]);
    
                if(i+1<copy_wordlist.size())
                {
                    word_puffer2 = copy_wordlist[i+1];
                    if((int)word_puffer2[0] > word[0])
                        break;
                }
            }
    
            if((int)word[0]<(int)word_puffer[0]) //kleiner
            {
                if(puffer1.size() == 0)
                {
                    copy_wordlist.insert(copy_wordlist.begin()+i, word);
                    break;
                }
    
                if(puffer1.size()>0)
                {
                    copy_wordlist.insert(copy_wordlist.begin()+i, word);
                    break;
                }
            }
        }
    
        if(puffer1.size() > 0)
        {
            for(int i=0; ; i++)
            {
                if(place == word.size())
                {
                    word_puffer2 = word;
                    break;
                }
    
                if(puffer1.size() > 0)
                {
                    place++;
    
                    word_puffer2 = puffer1[0];
    
                    if(place == word.size() || place == word_puffer2.size())
                        break;
    
                    for(int j=0; ; j++)
                    {
                        word_puffer = puffer1[0];
    
                        if((int)word[place] > (int)word_puffer[place])
                        {
                            if(puffer1.size() == 0)
                            {
                                word_puffer2 = word_puffer;
                                break;
                            }
    
                            puffer1.erase(puffer1.begin()+0);
                        }
    
                        if((int)word[place] == (int)word_puffer[place])
                        {
                            if(puffer1.size() == 0)
                                break;
    
                            puffer2.push_back(word_puffer);
                            puffer1.erase(puffer1.begin());
    
                            if(puffer1.size() == 0)
                            {
                                break;
                            }
                        }
    
                        if((int)word[place] < (int)word_puffer[place])
                        {
                            if(puffer1.size() == 0)
                                break;
    
                            word_puffer2 = puffer1[0];
    
                            for(int k=0; ; k++)
                            {
                                puffer1.erase(puffer1.begin()+0);
    
                                if(puffer1.size() == 0)
                                    break;
                            }
    
                            if(puffer1.size() == 0)
                                break;
                        }
                    }
                }
    
                if(puffer2.size() > 0)
                {
                    place++;
    
                    word_puffer2 = puffer2[0];
    
                    if(place == word.size() || place == word_puffer2.size())
                        break;
    
                    for(int k=0; ; k++)
                    {
                        word_puffer = puffer2[0];
    
                        if((int)word[place] > (int)word_puffer[place])
                        {
                            if(puffer2.size() == 0)
                            {
                                word_puffer2 = word_puffer;
                                break;
                            }
    
                            puffer2.erase(puffer2.begin()+0);
                        }
    
                        if((int)word[place] == (int)word_puffer[place])
                        {
                            if(puffer2.size() == 0)
                            {
                                break;
                            }
    
                            puffer1.push_back(word_puffer);
                            puffer2.erase(puffer2.begin());
    
                            if(puffer2.size() == 0)
                            {
                                break;
                            }
                        }
    
                        if((int)word[place] < (int)word_puffer[place])
                        {
                            word_puffer2 = puffer2[0];
    
                            for(int k=0; ; k++)
                            {
                                puffer2.erase(puffer2.begin()+0);
    
                                if(puffer2.size() == 0)
                                    break;
                            }
    
                            if(puffer2.size() == 0)
                                break;
                        }
                    }
                }
    
                if(puffer1.size() == 0 && puffer1.size() == 0)
                {
                    break;
                }
            }
        }
    
        for(int l=0; l<copy_wordlist.size(); l++)
        {
            word_puffer = copy_wordlist[l];
    
            if(word_puffer == word_puffer2)
            {
                if((int)word_puffer[place] > (int)word[place])
                {
                    copy_wordlist.insert(copy_wordlist.begin()+l, 1, word);
                    break;
                }
    
                if((int)word_puffer[place-1] == (int)word[place-1])
                {
                    if(word.size() < word_puffer.size())
                    {
                        copy_wordlist.insert(copy_wordlist.begin()+l, 1, word);
                        break;
                    }
    
                    if(word.size() > word_puffer.size())
                    {
                        copy_wordlist.insert(copy_wordlist.begin()+l+1, 1, word);
                        break;
                    }
                }
    
                if((int)word_puffer[place] < word[place])
                {
                    copy_wordlist.insert(copy_wordlist.begin()+l+1, 1, word);
                    break;
                }
            }
        }
    }
    
    //main()
    #include "sorter.h"
    #include <iostream>
    #include <vector>
    using namespace std;
    using namespace sorter;
    
    // Alphabetisierer, welcher anhand der ASCII-Werte der Chars in Strings die Wörter alphabetisch sortiert.
    int main()
    {
        string word;
        char answer;
        vector<string> wordlist;
    
        cout << "Geben Sie ein Wort ein!" << endl;
        cin >> word;
        wordlist.push_back(word);
    
        cout << "Ein weiteres Wort eingeben? ja: j, nein: n" << endl;
    
        cin >> answer;
        if(answer == 'j')
        {
            do
            {
                cin >> word;
                sort_func/*<vector<string>, string>*/(wordlist, word);
                cout << "Ein weiteres Wort eingeben? ja: j, nein: n" << endl;
                cin >> answer;
            }while(answer == 'j');
        }
    
        cout << "\n";
    
        for(unsigned int i=0; i<wordlist.size(); i++)
        {
            cout << wordlist[i] << endl;
        }
    
        return 0;
    }
    

    Warum spuckt mir Code::Blocks als einzigen Fehler das hier aus?:
    undefined reference to `void sorter::sort_func<std::vector<std::string, std::allocatorstd::string >, std::string>(std::vector<std::string, std::allocatorstd::string >&, std::string)'|

    Ich habe echt keine Ahnung was ich falsch gemacht haben könnte.
    Danke schon mal für eure Antworten und einen guten Rutsch euch gleich! 🙂
    JTR



  • Templates werden im Header implementiert, nicht in einer separaten cpp-Datei.

    Es gibt Ausnahmen, das ist aber nicht Anfängerstoff.



  • @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

    template<typename T, typename U>
    void sorter::sort_func(T &copy_wordlist, U word)
    {
    // ...
    }
    

    wtf??

    @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

       cin >> answer;
        if(answer == 'j')
        {
            do
            {
                cin >> word;
                sort_func/*<vector<string>, string>*/(wordlist, word);
                cout << "Ein weiteres Wort eingeben? ja: j, nein: n" << endl;
                cin >> answer;
            }while(answer == 'j');
        }
    

    wtf??



  • @Swordfish Was hast du?



  • Ich habs auch grad gelesen und hab mich auch gefragt, was Swordfish genau meint. Und dann hab ich den Originalcode angeschaut, und nehme an, das ist alles ein großes WTF.

    Der Code ist schon ziemlich seltsam. Wie kommst Du auf sowas?



  • @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

    @Swordfish Was hast du?

    @Mechanics sagte in Warum meckert Code::Blocks "undefined reference"?:

    das ist alles ein großes WTF.

    @Mechanics sagte in Warum meckert Code::Blocks "undefined reference"?:

    Der Code ist schon ziemlich seltsam. Wie kommst Du auf sowas?



  • Ist halt ein Programm zur alphabetischen Sortierung für Wörter beliebiger Länge.
    Was ist denn daran so seltsam?
    Ich mein, er ist nicht das, was normale Funktionen tun, aber er läuft einwandfrei.



  • Mehr als 200 Lines um zu sortieren? Hast Du fieber? Arzt?

    #include <string>
    #include <vector>
    #include <iostream>
    
    template <class Iterator>
    void sort(Iterator begin, Iterator end) {
        for (Iterator i = begin; i != end; ++i)
            for (Iterator j = begin; j < i; ++j)
                if (*i < *j)
                    std::iter_swap(i, j);
    }
    
    int main()
    {
        std::vector<std::string> words;
        char choice;
        while (std::cout << "Enter another word (y/n)?\n",
               (std::cin >> choice) && choice == 'y')
        {
            std::string word;
            std::cin >> word;
            words.push_back(word);
        }
    
        sort(std::begin(words), std::end(words));
        for (auto const &word : words)
            std::cout << word << '\n';
    }
    


  • @Swordfish Ich glaube, ich sollte den Code mal erklären.
    Also es geht halt darum, dass man ein Wort in einer Liste von anderen Wörtern an die alphabetisch korrekte Stelle einfügt.
    Dazu nimmt man sich den ersten Buchstaben eines neuen string word und castet ihn den erste, zweite usw. char auf int um, damit die Ascii-Werte der ersten Buchstaben der anderen Wörter verglichen werden können.
    Wenn es noch ein anderes Wort gibt, welches bspw. mit W beginnt, wird dieses in einen Vektor puffer1 gepackt. So auch das nächste Wort aus der Liste. Das geht so weit, bis alle Wörter mit dem Anfangsbuchstaben W in puffer1 stehen.
    Dann springt man zum 2. Buchstaben der Wörter und schaut, welche Wörter in puffer1 ebenfalls an zweiter Stelle den sagen wir mal Buchstaben o haben.
    Diese werden dann aus puffer1 gelöscht und in puffer 2 geschrieben.
    Natürlich wird alles aus puffer 1 gelöscht, sodass er wieder leer ist.
    Dann schaut man sich die dritten Buchstaben an und vergleicht wieder, ob die dritte Stelle von word gleich der dritten Stelle eines Wortes aus puffer2 ist.

    Dieses Ping-Pong-Spiel geht so weit, bis man nur noch ein Wort in entweder puffer1 oder puffer2 hat.
    Dann schaut man nur noch nach, wo in der Wortliste dieses letzte Wort ist und fügt word davor oder dahinter ein.



  • Long story short: Du willst ein Wort sortiert in einen bereits sortierten Conainer einfügen?



  • This post is deleted!


  • @Swordfish Jop, genau! 🙂



  • #include <string>
    #include <vector>
    #include <iostream>
    #include <algorithm>
    
    template<typename T>
    void insert_sorted(T &v, typename T::value_type const &item)
    {
        v.insert(std::upper_bound(std::begin(v), std::end(v), item), item);
    }
    
    int main()
    {
        std::vector<std::string> words;
        char choice;
        std::cout << "Your list of words:\n";
        while (std::cout << "Enter another word (y/n)?\n",
               (std::cin >> choice) && choice == 'y')
        {
            std::cout << "Next word: ";
            std::string word;
            std::cin >> word;
            words.push_back(word);
        }
    
        std::cout << "Word to insert: ";
        std::string word;
        std::cin >> word;
        insert_sorted(words, word);
    
        for (auto const &word : words)
            std::cout << word << '\n';
    }
    


  • @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

    castet ihn den erste, zweite usw. char auf int um, damit die Ascii-Werte der ersten Buchstaben der anderen Wörter verglichen werden können.

    Ist auch eine Theorie auf sehr wackligen Beinen.



  • @Swordfish Dann ist nur meine Frage, wie die Sortierfunktion upper_bound aussieht, denn er muss ja die einzelnen Buchstaben des Wortes zu int casten, weil er ja sonst nicht der Größe nach sortieren kann.

    Wie meinst du das mit den sehr wackeligen Beinen?
    Sortieren geht ja bei Buchstaben am besten nach den Ascii-Werten...



  • @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

    denn er muss ja die einzelnen Buchstaben des Wortes zu int casten

    Wie kommst du auf diese Idee?

    @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

    Dann ist nur meine Frage, wie die Sortierfunktion upper_bound aussieht

    https://en.cppreference.com/w/cpp/algorithm/upper_bound#Possible_implementation



  • @Swordfish Na ja, weil ich mir halt gedacht habe, dass jeder Buchstabe einen Ascii-Wert hat und man anhand diesen Wertes kann man ja wunderbar sortieren kann.



  • ja. schön.

    char a = 'A';
    char b = 'B';
    

    warum soll ich jetzt a und b nicht vergleichen können? Warum soll ich die zuerst nach int casten müssen??

    char, short, int, long, long long ... das sind alles Integer-Typen.



  • @Swordfish Weil halt die Ascii-Werte der Buchstaben allesamt im int-Bereich liegen.
    ein long int brauchste halt für (int)a == 65 halt nicht. Also das andere wäre auch gegangen, logisch, aber nicht nötig gewesen.



  • Ein char ist auch nur ein numerischer Wert. Ein cast zu int bringt genau garnichts.

    @JTR666 sagte in Warum meckert Code::Blocks "undefined reference"?:

    a == 65

    Wenn Du 'A' meinst dann schreib' bitte auch 'A'.


Log in to reply