Fehlermeldung :no matching function for call to ‘SingleList::ListElem::ListElem(int**, SingleList::ListElem**)



  • #include <iostream>
    using namespace std;
    
    class SingleList {
    
    class ListElem {
    private :
    int elem;
    ListElem*m_next;
    
    public :
        ListElem (int i, ListElem*next){
        elem = i;
        *m_next = *next;
        }
    
    
        ListElem(const int ii,const ListElem*nextt){
        elem = ii;
        *m_next = *nextt;
        }
      //  ListElem& operator=(const ListeElem*m_next);
        ~ListElem(){
        ListElem* m_next = m_head;
        while(m_next){
            ListElem*loescheMich = m_next;
            m_next = m_next->m_next;
            delete loescheMich;
        }
        }
    
    
    };
    public :
    static ListElem*m_head;
    static ListElem*m_tail;
    
    void push_front(int i){
    m_head = new ListElem(i,&m_head); <<<GENAU HIER TRITT DER FEHLER AUF
    
    if(m_head == null)
        {
            m_head = m_tail = new ListElem(i,null);
        }
    }
    void push_back(int i){
    if(m_head == null)
        {
            m_tail = m_head = new ListElem(i,null);
        }
    else
       {
           m_tail->m_next = new ListElem(i, null);
           m_tail = m_tail->m_next;
    
       }
    }
    void delete_vorne(){
    ListElem* tmp = new ListElem();
    
    tmp = m_head;
    m_head = m_head->m_next;
    delete tmp;
    }
    void delete_hinten(){
    ListElem*aktueller = new ListElem();
    ListElem*vorg = new ListElem();
    
    aktueller  = m_head;
    while(aktueller->m_next != null)
         {
           vorg = aktueller;
           aktueller = aktueller->m_next;
         }
         m_tail = vorg;
         vorg->m_next = null;
         delete aktueller;
    
    }
    void delete_ueberall(int position){
    ListElem*aktueller = new ListElem();
    ListElem*vorg = new ListElem();
    aktueller = m_head;
    for(int i = 1; i < position ; i++)
       {
         vorg = aktueller;
        aktueller = aktueller->m_next;
       }
       vorg->m_next = aktueller->m_next;
    }
    int size(){
    int*zaehler = 0;
    for(ListElem tmp = m_head; tmp != null; tmp = m_head->m_next)
        {
            *zaehler.operator++(1);
        }
        return *zaehler;
    }
    void print(){
    for(ListElem tmp = m_head; tmp != null;tmp = m_head->m_next)
        {
            cout<<" "<<tmp->elem<<""<<endl;
        }
    }
    };
    int main()
    {
         SingleList l1 = new  SingleList();
        for(int i = 0; i < 10;++i)
           {
               int*pointeur = i;
               l1.push_front(&pointeur);
           }
            return 0;
    }
    


  • Ich werde meine Kommentare nicht wiederholen.



  • @manni66
    ich denke könnte auch freundlicher gehen:)
    was denn mach ich falsch ?



  • @seakowski sagte in Fehlermeldung :no matching function for call to ‘SingleList::ListElem::ListElem(int**, SingleList::ListElem**):

    @manni66
    ich denke könnte auch freundlicher gehen:)

    Viel Spaß noch bei der Felersuche.



  • @manni66
    danke , hab mich sehr gefreut 🙂


  • Global Moderator |  Mod

    Wenn m_head ein static ListElem* ist, von welchem Typ ist dann &m_head? Was erwartet der Konstruktor von ListElem? Was sagt die Fehlermeldung?

    Insgesamt würde ich aber laut brüllen: Stopp!
    Der Code und das Gesamtdesign sind derzeit so schlecht, das wird nie funktionieren. Es macht auch kaum Spaß, den Code überhaupt anzugucken, weil einem schwindelig wird vor lauter merkwürdigen Bezeichnern. Aber insgesamt wird schnell klar, dass die beste Vorgehensweise wohl wäre, alles komplett wegzuwerfen und noch einmal ganz in Ruhe, Schritt für Schritt, an die Sache ran zu gehen. Derzeit sind das mindestens 5 verschiedene Baustellen, die sich gegenseitig blockieren, und daher wird nichts davon jemals funktionieren.

    Du musst natürlich auch erst einmal Grundkonzepte lernen, denn deine Frage hier beantwortet sich eigentlich von alleine, wenn man Adressoperatoren und Pointer verstanden hat, was absolute Grundvoraussetzungen für der Programmieren einer Liste sind. Gewöhn dir vernünftige Bezeichner an. Gutes C++ liest sich nahezu wie Englische Prosa und wenn es das nicht tut, dann ist das oft ein starkes Anzeichen dafür, dass mit der Codelogik etwas nicht stimmt. Bei dir liest sich derzeit alles ganz merkwürdig. Daher ist entweder alles falsch (will ich nicht ausschließen) oder du hast dich selber dieses guten Mittels zur Fehlersuche beraubt durch den merkwürdigen Stil. Chaotische Bezeichner sind oft auch ein Zeichen für chaotisches, hektisches Programmieren. Da das nicht funktioniert, schrieb ich oben auch ausdrücklich, dass dies noch einmal langsam und in Ruhe neu gemacht werden sollte.

    Außerdem musst du dir dringend vorher mal ansehen, wie die Sprache C++ zur benutzen gedacht ist. Derzeit vergewaltigst du die Sprache ziemlich, und sie wehrt sich entsprechend. 90% deiner Probleme würden von ganz alleine verschwinden, wenn du die dynamische Speicherverwaltung sein lassen würdest (Ist es Kernaufgabe einer Liste, Speicher zu verwalten? Nein, sie soll Daten eine Struktur geben!) und diese an eine fertige Klasse auslagern würdest, die sich damit auskennt und das richtig macht. Dann könntest du dich auf die Kernfunktionalität der Liste konzentrieren, während du deine Liste programmierst. Dann hast du keine Ablenkungen und hast kleinere Einheiten, deren Funktionalität besser geprüft werden kann.

    Die Smartpointer aus C++ erledigen das bereits für dich. Wenn dein Lehrer darauf besteht, dass du die Speicherverwaltung selber programmierst, dann solltest du die Speicherverwaltung trotzdem aus der Liste auslagern. Dann musst du eben die Smartpointer nachprogrammieren. Auch hier fehlen aber erst einmal die Grundvoraussetzungen, die du zuerst lernen musst: RAII. Rule of Three. Rule of Five. Und auch die Rule of Zero, die erklärt, warum die Speicherverwaltung nicht Teil der Liste sein sollte.