Ankündigung

Einklappen
Keine Ankündigung bisher.

Verkettete Liste

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Verkettete Liste

    Hallo Leute, ich habe eine Doppelt verkettete Liste in C++ mit Visual Studio 2010 geschrieben. Compiliert/Funktioniert soweit ganz gut nur ich kriege den Fehler:

    Unbehandelte Ausnahme bei 0x771d15ee in list.exe: 0xC0000005: Zugriffsverletzung beim Lesen an Position 0x00000008.

    Ich habe durch Ausgaben die Stelle gefunden wo der Fehler entsteht, aber warum???

    hier die main.cpp:
    Code:
    #include <iostream>
    #include <string>
    
    #include "list.h"
    
    using namespace std;
    
    int main(){
    	//Ausgabe
    	cout << "Liste start!" << endl;
    
    	list* l = new list();
    	
    	cout << "Liste-Length: " << l->getLength() << endl;
    	
    	for(int i=0; i<10; ++i){
    		l->add(i);
    	}
    	
    	cout << "Liste-Length: " << l->getLength() << endl;
    
    	for(int i=0; i<10; ++i){
    		cout << "i: " << i << " Liste: " << l->get(i)->getData() << endl;  // <---------------- HIER TRITT DER FEHLER AUF !!!
    	}
    	
    	//Warten
    	system("pause");
    }
    hier mein code der list.h:
    Code:
    #pragma once
    
    #include "listE.h"
    
    class list{
    
    private:
    	int length;
    	listE start;
    	listE end;
    
    public:
    	//Konstruktor
    	list(void);
    
    	//Destruktor
    	~list(void);
    
    	//Funktionen
    	int getLength();
    	listE* get(int);
    	void add(int);
    	void add(listE*);
    	void ins(int, listE*);
    	void del(int);
    };
    hier der code der list.cpp:
    Code:
    #include "list.h"
    
    #include <iostream>
    
    //Kontruktor
    list::list(){
    	length=0;
    	start.setLast(&end);
    	start.setNext(&end);
    	end.setLast(&start);
    	end.setNext(&start);
    }
    
    //Destruktor
    list::~list(void){
    	//Speicher freigeben
    	delete(&length);
    	delete(&start);
    	delete(&end);
    }
    
    //Funktionen
    int list::getLength(){
    	return length;
    }
    
    listE* list::get(int index){
    	if(length<0){ return 0; }
    	else if(length>=0){
    		listE* tmp = start.getNext();
    		listE* tmp2= 0;
    		//Position suchen
    		for(int i=0; i<index; --i){
    			tmp2 = tmp->getNext();
    			tmp=tmp2;
    		}
    		return tmp;
    	}
    }
    
    hier der code der listE.h:
    void list::add(int x){
    	listE* neu = new listE(x);
    	add(neu);
    }
    
    void list::add(listE* neu){
    	neu->setNext(&end);
    	neu->setLast(end.getLast());
    	end.getLast()->setNext(neu);
    	end.setLast(neu);
    	++length;
    }
    
    void list::ins(int, listE*){
    
    }
    
    void list::del(int){
    
    }
    hier der code der listE.h:
    Code:
    #pragma once
    
    class listE{
    
    private:
    	int data;
    	listE* last;
    	listE* next;
    
    public:
    	//Konstruktor
    	listE(int, listE*, listE*);
    	listE(int, listE*);
    	listE(int);
    	listE(void);
    
    	//Destruktor
    	~listE(void);
    
    	//Funktionen
    	int getData();
    	listE* getLast();
    	listE* getNext();
    
    	void setData(int);
    	void setLast(listE*);
    	void setNext(listE*);
    
    };
    hier der code der listE.cpp:
    Code:
    #include "listE.h"
    
    //Konstruktor
    listE::listE(int x, listE* next, listE* last){
    	data=x;
    	next=next;
    	last=last;
    }
    
    listE::listE(int x, listE* next){
    	data=x;
    	next=next;
    	last=0;
    }
    
    listE::listE(int x){
    	data=x;
    	next=0;
    	last=0;
    }
    
    listE::listE(void){
    	data=0;
    	next=0;
    	last=0;
    }
    
    //Destruktor
    listE::~listE(){
    	//Speicher freigeben
    	delete(&data);
    	delete(last);
    	delete(next);
    }
    
    //Funktionen
    
    int listE::getData(){
    	return data;
    }
    
    listE* listE::getLast(){
    	return last;
    }
    
    listE* listE::getNext(){
    	return next;
    }
    
    void listE::setData(int x){
    	data=x;
    }
    
    void listE::setLast(listE* last){
    	last=last;
    }
    
    void listE::setNext(listE* next){
    	next=next;
    }
    VIELEN DANK schonmal für die Hilfe! ;-)

  • #2
    Hallo ,

    zunächst einmal hoffe ich das du weißt, dass die STL in C++ mit std::list bereits eine doppelt verkettete Liste zur Verfügung stellt.

    http://www.cplusplus.com/reference/stl/list/

    Es ist also nicht erforderlich diese selbst zu schreiben.

    Falls dein Code Übungszwecken oder ähnlichem dient, dann können wir uns gemeinsam den Code näher ansehen. Die Zugriffsverletzung deutet immer darauf hin, dass das Programm versucht auf Speicher zuzugreifen, der nicht zum Adressraum gehört. Kurzum, du hast einen Dangling Pointer bzw. wild Pointer.

    Zunächst hast du zwei Klassen, nämlich list und listE. Die zweite Klasse ist im Prinzip ein Knoten (engl. Node). Versuche die Funktionalität in eine Klasse zu packen! Der Knoten oder das Listenelement, besteht ja nur aus einem Datenstück und den beiden Zeigern. Es reicht daher im inneren ein struct zu definieren. Halte dich dabei an das Schema einer doppelt verketteten Liste mit zwei Zeigern.

    Klicke auf die Grafik für eine vergrößerte Ansicht

Name: 610px-Doubly-linked-list.svg.png
Ansichten: 2
Größe: 3,9 KB
ID: 1563

    Wenn ich deinen Code kurz überfliege, dann kann ich zu 99 % die Aussage treffen das der Code in der Methode add() nicht korrekt ist. Er muss nämlich zum einen verschiedene Fälle berücksichtigen, z.B. ob der Kopf (start) Null ist. Die Variable start wird bei dir überhaupt nicht gesetzt.

    Auch das Löschen der Liste im Destruktor kann nicht stimmen. Du musst eigentlich durch die gesamte Liste iterieren und delete aufrufen. Insbesondere die folgende Zeile ist falsch.

    PHP-Code:
    delete(&length); 
    Du rufst delete auf einem Integer (int) auf, den du zuvor mit & dereferenzierst. Autsch! Außerdem rufst du delete auf start und end auf, obwohl diese Objekte statische Objekte der Klasse list sind. Du darfst nur auf Objekten delete aufrufen, die mit new erzeugt wurden!

    Ich habe vor einigen Jahren eine doppelte-verkettete Liste als Template geschrieben, ähnlich der in der STL. Sie hat ein paar zusätzliche Features. Hier ist der Code.

    Werfe einen Blick auf die Methode push_back(). Dort ist das Beispiel zu sehen, wie korrekt in die Liste eingefügt wird. Die Methode clear() zeigt, wie die Liste gelöscht wird. Beachte die Schleife, die durch die Liste iteriert und jedes Element löscht!

    PHP-Code:
    #ifndef _LINKEDLIST_H_
    #define _LINKEDLIST_H_

    /////////////////////////////////////////////////////////////
    // A doubly-linked list. T is always a deep copy. This 
    // template class is similar to the STL list. You can easily
    // replace it, if you wish, the interface is exactly the same.
    /////////////////////////////////////////////////////////////

    #include <iterator>
    #include <cassert>
    using namespace std;

    template<typename T>
    class 
    LinkedList
    {
    private:
        
    void copyList(const LinkedList<T>&);

    protected:
        
    struct Node
        
    {
            
    Node(T val)
                : 
    value(val), next(NULL), prev(NULL)
            { }

            
    T value;
            
    Node *next;
            
    Node *prev;
        };

        
    size_t m_size;
        
    Node *m_head;
        
    Node *m_tail;

    public:
        class 
    const_iterator
            
    : public std::iterator<std::forward_iterator_tagTsize_tconst*, const&>

        {
        public:
            
    typedef std::forward_iterator_tag
            iterator_category
    ;
            
    typedef T         value_type;
            
    typedef ptrdiff_t difference_type;
            
    typedef T const*  pointer;
            
    typedef T const&  reference;

            
    const_iterator(Node *node NULL)
                : 
    current(node)
            {}

            
    reference operator*()
            {
                return 
    current->value;
            }

            
    pointer operator->()
            {
                return &(**
    this);
            }

            
    // If no arguments it is the prefix ++
            
    const_iteratoroperator++()
            {
                
    current current->next;
                return *
    this;
            }

            
    // With arguments it is the postfix ++
            
    const_iterator operator++(int)
            {
                
    const_iterator old_iterator = *this;
                ++(*
    this);
                return 
    old_iterator;
            }

            
    const_iteratoroperator--()
            {
                
    assert(current->prev != NULL);
                
    current current->prev;
                return *
    this;
            }
            
            
    const_iterator operator--(int)
            {
                
    const_iterator old_iterator = *this;
                --(*
    this);
                return 
    old_iterator;
            }
            
            
    bool operator==(const_iterator const& rhs)
            {
                return 
    current == rhs.current;
            }

            
    bool operator!=(const_iterator const& rhs)
            {
                return !(*
    this == rhs);
            }

            protected:
                
    Nodecurrent;
        };

        class 
    iterator : public const_iterator
        
    {
        public:
            
    iterator(Node *node NULL)
                : 
    const_iterator(node)
            {}

            
    typedef std::forward_iterator_tag iterator_category;
            
    typedef T      value_type;
            
    typedef size_t difference_type;
            
    typedef T*     pointer;
            
    typedef T&     reference;

            
    using const_iterator::current;

            
    reference operator*()
            {
                return 
    current->value;
            }

            
    pointer operator->()
            {
                return &(**
    this);
            }

            
    iteratoroperator++()
            {
                
    current current->next;
                return *
    this;
            }

            
    iterator operator++(int)
            {
                
    iterator old_iterator = *this;
                ++(*
    this);
                return 
    old_iterator;
            }

            
    iteratoroperator--()
            {
                
    assert(current->prev != NULL);
                
    current current->prev;
                return *
    this;
            }
            
            
    iterator operator--(int)
            {
                
    iterator old_iterator = *this;
                --(*
    this);
                return 
    old_iterator;
            }

            
    iterator operator+(const int offset
            {
                for(
    int i 0; (*this != NULL) && (offset); i++) {
                    ++(*
    this);
                }

                return *
    this;
            }
        };

        
    LinkedList();
        
    LinkedList(const LinkedList<T>&);
        
    LinkedList<T>& operator=(const LinkedList<T>&); 
        ~
    LinkedList();
        
    bool empty() const;
        
    size_t size() const;
        
    void clear();
        
    T front() const;
        
    T back() const;
        
    void remove(const T&);
        
    void push_front(const T&);
        
    void push_back(const T&);
        
    void pop_front();
        
    bool exists(const T&) const;
        
    iterator begin();
        
    iterator end();
        
    const_iterator begin() const;
        
    const_iterator end() const;
        
    void insert(iterator, const T&);
        
    iterator erase(iterator);
        
    iterator erase(iteratoriterator);
        
    friend ostreamoperator<<(ostream&, const LinkedList<T>&);
        
    friend class LinkedList<T>::iterator;
        
    void print() const;
    };

    template<typename T>
    inline LinkedList<T>::LinkedList()
        : 
    m_head(NULL), m_tail(NULL), m_size(0)
    {
    }

    template<typename T>
    inline LinkedList<T>::LinkedList(const LinkedList<T>& rhs)
        : 
    m_head(NULL), m_tail(NULL), m_size(0)
    {
        
    copyList(rhs);
    }

    template<typename T>
    inline LinkedList<T>::~LinkedList()
    {
        
    clear();
    }

    template<typename T>
    LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T>& rhs)

        if(
    this == &rhs)
            return *
    this

        
    copyList(rhs);

        return *
    this;
    }

    template <typename T>
    inline typename LinkedList<T>::iterator LinkedList<T>::begin()
    {
        return 
    iterator(m_head);
    }

    template <typename T>
    inline typename LinkedList<T>::iterator LinkedList<T>::end()
    {
        return 
    iterator(NULL);
    }

    template <typename T>
    inline typename LinkedList<T>::const_iterator LinkedList<T>::begin() const
    {
        return 
    const_iterator(m_head);
    }

    template <typename T>
    inline typename LinkedList<T>::const_iterator LinkedList<T>::end() const
    {
        return 
    const_iterator(NULL);
    }

    template <typename T>
    inline void LinkedList<T>::insert(typename LinkedList<T>::iterator position, const Tx)
    {
        
    NodenewNode = new Node(x);

        
    // Insert before iterator position like std::list::insert(), 
        // iterator position remains untouched
        
    if(m_head == position.current) {
            
    newNode->prev NULL;
            
    newNode->next m_head;
            if(
    m_head != NULL) {
                
    m_head->prev newNode;
            } else {
                
    m_tail newNode;
            }
            
    m_head newNode;
        } else {
            
    newNode->prev position.current->prev;
            
    newNode->next position.current;
            
    position.current->prev->next newNode;
            
    position.current->prev newNode;
        }

        
    m_size++;
    }

    template<typename T>
    inline typename LinkedList<T>::iterator LinkedList<T>::erase(typename LinkedList<T>::iterator position)
    {
        
    NodetoDelete position.current;

        
    typename LinkedList<T>::iterator newIterator(position.current->next);

        if(
    position.current == m_head && position.current == m_tail) {  // Erase head & tail
            
    m_head NULL;
            
    m_tail NULL;
            
    position.current NULL;
        } else if(
    position.current == m_head) {    // Erase head
            
    position.current->next->prev NULL;
            
    m_head position.current->next;
        } else if(
    position.current == m_tail) {   // Erase tail
            
    position.current->prev->next NULL;
            
    m_tail position.current->prev;
        } else {    
    // Erase somewhere in the middle
            
    position.current->prev->next position.current->next;
            
    position.current->next->prev position.current->prev;
        }

        
    delete toDelete;

        
    m_size--;

        return 
    newIterator;
    }

    template<typename T>
    inline typename LinkedList<T>::iterator LinkedList<T>::erase(typename LinkedList<T>::iterator first,
        
    typename LinkedList<T>::iterator last)
    {
        
    typename LinkedList<T>::iterator it(first);

        while(
    it != last) {
            
    it erase(it);
        }

        return 
    it;
    }

    template<typename T>
    inline void LinkedList<T>::copyList(const LinkedList<T>& otherList)
    {
        
    // Perform copy
        
    Node *newNode;
        
    Node *current;

        if(
    m_head != NULL) {
            
    clear();
        }

        
    // If other list is empty
        
    if(otherList.m_head == NULL) {
            
    m_head NULL;
            
    m_tail NULL;
            
    m_size 0;
        } else {
            
    current otherList.m_head
            
    m_size otherList.m_size;
            
    m_head = new Node(current->value);

            
    assert(m_head != NULL);

            
    m_head->next NULL;                                           
            
    m_tail m_head;                                         
            
    current current->next;                          

            
    // Copy the remaining list
            
    while(current != NULL) {
                
    newNode = new Node(current->value); 

                
    assert(newNode != NULL);

                
    newNode->next NULL;       
                              
                
    m_tail->next newNode
                
    newNode->prev m_tail;
                
    m_tail newNode;           
                                            
                
    current current->next;                                       
            }
        }
    }

    template<typename T>
    bool LinkedList<T>::empty() const
    {
        return (
    m_size == 0);
    }

    template<typename T>
    void LinkedList<T>::clear()
    {
        
    Node *temp;   

        while(
    m_head != NULL) {
            
    temp m_head;
            
    m_head m_head->next;
            
    delete temp;
        }

        
    m_tail NULL;

        
    m_size 0;
    }

    template <typename T>
    inline void LinkedList<T>::pop_front()
    {
        
    NodedeadNode m_head;
        
    m_head m_head->next;

        if (
    m_head == NULL) {
            
    m_tail NULL;
        } else {
            
    m_head->prev NULL;
        }
        
        
    delete deadNode;

        
    m_size--;
    }

    template<typename T>
    inline size_t LinkedList<T>::size() const
    {
        return 
    m_size;
    }

    template<typename T>
    T LinkedList<T>::front() const
    {   
        
    assert(m_head != NULL);
        return 
    m_head->value;
    }


    template<typename T>
    T LinkedList<T>::back() const
    {   
        
    assert(m_tail != NULL);
        return 
    m_tail->value;
    }

    template<typename T>
    bool LinkedList<T>::exists(const Tx) const
    {
        
    Node *current;
        
    bool found;

        
    current m_head

        
    found false;

        while(
    current != NULL && !found) {
            if(
    current->value == x) {
                
    found true;
            } else {
                
    current current->next;
            }
        }
         
        return 
    found;
    }

    template<typename T>
    inline void LinkedList<T>::push_front(const Tx)
    {
        
    Node *newNode = new Node(x);

        
    assert(newNode != NULL);

        
    m_head->prev newNode;
        
    newNode->next m_head;
        
    m_head newNode;
                         
        if(
    m_tail == NULL) {
            
    m_tail newNode;
        }

        
    m_size++;
    }

    template<typename T>
    inline void LinkedList<T>::push_back(const Tx)
    {
        
    Node *newNode = new Node(x);

        
    assert(newNode != NULL);

        
    newNode->next NULL;

        if(
    m_head == NULL) {
            
    m_head newNode;
            
    m_tail newNode;
            
    m_size++;
        } else {
            
    m_tail->next newNode;
            
    newNode->prev m_tail;
            
    m_tail newNode;
            
    m_size++;
        }
    }

    template<typename T>
    void LinkedList<T>::remove(const Tvalue)
    {
        
    Node *current;
        
    Node *trailCurrent;
        
    bool found;

        if(
    m_head != NULL) {
            if(
    m_head->value == value) {
                
    current m_head;
                
    m_head m_head->next;
                
    m_head->prev NULL;
                if(
    m_head == NULL) {
                    
    m_tail NULL;
                }
                
    delete current;
                
    m_size--;
            } else {
                
    found false;
                
    trailCurrent m_head;
                
    current m_head->next;
        
                while(
    current != NULL && !found) {
                      if(
    current->value != value) {
                        
    trailCurrent current;
                        
    current current->next;
                    } else {
                        
    found true;
                    }
                }

                if(
    found) {
                    
    trailCurrent->next current->next;
                    
                    if(
    m_tail == current) {
                        
    m_tail trailCurrent;
                    } else {
                        
    current->next->prev trailCurrent;
                    }

                    
    delete current;
                    
    m_size--;
                }
            }
        } 


    template<typename T>
    inline void LinkedList<T>::print() const
    {
        
    Node *cur m_head;

        if(
    cur == NULLstd::cout << "Empty list. " << std::endl;

        while(
    cur != NULL) {    // For debug
            
    if(cur->prev == NULL) {
                
    std::cout << "NULL <- ";
            } else {
                
    std::cout << cur->prev->value << " <- ";
            }
            
    std::cout << cur->value;
            if(
    cur->next == NULL) {
                
    std::cout << " -> NULL" << std::endl;
            } else {
                
    std::cout << " -> " << cur->next->value << std::endl;
            }
            
    cur cur->next;
        }
    }

    #endif 
    Den Code kannst du, wie folgt benutzen.

    PHP-Code:
    #include <iostream>
    #include <string>

    #include "list.h"

    using namespace std;

    int main()
    {
        
    LinkedList<intmylist;
        
    LinkedList<int>::iterator it;

        
    // set some initial values:
        
    for (int i 1<= 5i++) 
            
    mylist.push_back(i); // 1 2 3 4 5

        
    cout << "Liste-Length: " << mylist.size() << endl;

        for (
    it mylist.begin(); it != mylist.end(); it++)
            
    cout << " " << *it;

        
    // oder mylist.print(); um die verkettete Liste anzuzeigen
        
        //Warten
        
    system("pause");

    Gruß,
    GAGA
    Zuletzt geändert von GAGA; 06.01.2012, 02:50.

    Kommentar


    • #3
      Vielen Dank GAGA!
      Deine ausführliche Beschreibung hat mir schonmal geholfen. Code ist nur zur Übung. Ich bin neu in C++ hab bisher nur Java intersiver gemacht.

      Zu der add() Methode kann ich nur sagen, das der Code zu 100% stimmt, weil
      Klicke auf die Grafik für eine vergrößerte Ansicht

Name: cpp0.jpg
Ansichten: 1
Größe: 35,1 KB
ID: 1564
      Wie man hier sieht füge ich ein Element immer zwischen 2 Bestehende ein. Da nun das neue E-1 den Platz von start eingenommen hat bleibt die Methode immer die gleiche, egal wo ich in der Liste etwas einfüge.
      Die Nr. 1-4 stehen für die Reihenfolge in der ich die Pointer in Code ändere.

      Sag mal, muss ich die listE start/end erst mit new listE(); initialisieren???
      Die Destruktoren hab ich noch nicht gemacht, weil dazu noch nicht gekommen bin^^ aber trotzdem danke.
      Sorry aber bei deinem Code versteh ich wenig, außer die Funktionen an sich.

      ich such mal weiter nach dem Fehler...

      Kommentar


      • #4
        Hallo maxPetersen67!

        Glaube mir, die Methode add() ist fehlerhaft. Das liegt daran das dein Ansatz nicht stimmt. Die Klasse list hat bei dir folgende Member.

        PHP-Code:
        private:
            
        int length;
            
        listE start;
            
        listE end
        Das entspricht nicht einer doppelt verketteten Liste. Der Anfang und das Ende sind nämlich keine Listenelemente, sondern nur Zeiger. Siehe Bild:

        Klicke auf die Grafik für eine vergrößerte Ansicht

Name: 610px-Doubly-linked-list.svg.png
Ansichten: 2
Größe: 3,9 KB
ID: 1565

        Korrekt müsste es also heißen.

        PHP-Code:
        private:
            
        int length;
            
        listEstart;    // <- Ein Zeiger vom Typ listE
            
        listEend
        Neue Datenelemente werden dann mit new erzeugt. Zum Beispiel sieht das so aus, wenn das erste Element hinzugefügt wird:

        PHP-Code:
        // Prinzipiell müssen immer 4 Zeiger bei einer doppelt verketteten Liste verändert werden!
        listEneu = new listE(x);
        neu->setNext(NULL);    // Next von neu zeigt auf NULL, weill danach kein Listenelement mehr kommt
        neu->setLast(NULL);    // Last von neu zeigt auch auf NULL, weill davor kein Listenelement kommt
        start neu;    // Der Start ist nun das neue Element
        end neu;    // Das Ende ist aber auch das neue Element, da wir ja nur ein Element in der Liste haben
        ++length
        Beachte das der Code nur für das erste Einfügen gilt! Sobald ein zweites Element eingefügt wird, muss eine Fallunterscheidung (if) stattfinden.

        Lösche komplett den Inhalt im Destruktor.

        PHP-Code:
        //Destruktor
        list::~list(void){
            
        //Speicher freigeben
            
        delete(&length);
            
        delete(&start);
            
        delete(&end);

        Das ist vollständig fehlerhaft! delete darf nur an Objekten aufgerufen werden, die auch mit new erzeugt wurden!

        PHP-Code:
        Object= new Object();
        delete(o); 
        Gruß,
        GAGA
        Zuletzt geändert von GAGA; 06.01.2012, 15:30.

        Kommentar


        • #5
          thx^^ funktioniert jetzt!!! ja irgendwie war mein konzept schrott.
          ich schreib die klassen mal fertig und stell die dann mal hier online.

          Kommentar


          • #6
            Ich helfe dir einmal beim Ansatz.

            PHP-Code:
            #ifndef _LIST_H_
            #define _LIST_H_

            #include "listE.h"

            class list{

            private:
                
            int length;
                
            listEstart;
                
            listEend;

            public:
                
            //Konstruktor
                
            list(void);

                
            //Destruktor
                
            ~list(void);

                
            //Funktionen
                
            int getLength();
                
            listEget(int);
                
            void add(int);
                
            void add(listE*);
                
            void ins(intlistE*);
                
            void del(int);
                
            void clear();
            };

            #endif 
            PHP-Code:
            #include "list.h"

            #include <iostream>

            //Kontruktor
            list::list()
                : 
            length(0), start(NULL), end(NULL)
            {
            }

            //Destruktor
            list::~list(void){
                
            //Speicher freigeben
                
            clear();
            }

            //Funktionen
            int list::getLength(){
                return 
            length;
            }

            listE* list::get(int index){
                if(
            index || index >= length) { return NULL; }

                
            listEtmp start;
                
            //Position suchen
                
            for(int i 0indexi++){
                    if(
            == index) return tmp;
                    
            tmp tmp->getNext();
                }

                return 
            tmp;
            }

            void list::add(int x)
            {
                
            listEnewNode = new listE(x);

                
            add(newNode);
            }

            void list::add(listEnewNode)
            {
                
            newNode->setNext(NULL);

                if(
            start == NULL) {
                    
            start newNode;
                    
            end newNode;
                    
            length++;
                } else {
                    
            end->setNext(newNode);
                    
            newNode->setLast(end);
                    
            end newNode;
                    
            length++;
                }
            }

            void list::clear()
            {
                
            listE *temp;   

                while(
            start != NULL) {
                    
            temp start;
                    
            start start->getNext();
                    
            delete temp;
                }

                
            end NULL;

                
            length 0;
            }

            void list::ins(intlistE*){

            }

            void list::del(int){


            PHP-Code:
            #ifndef _LISTELEMENT_H_
            #define _LISTELEMENT_H_

            #include <iostream>

            class listE{

            private:
                
            int data;
                
            listElast;
                
            listEnext;

            public:
                
            //Konstruktor
                
            listE(intlistE*, listE*);
                
            listE(intlistE*);
                
            listE(int);
                
            listE(void);

                
            //Destruktor
                
            ~listE(void);

                
            //Funktionen
                
            int getData();
                
            listEgetLast();
                
            listEgetNext();

                
            void setData(int);
                
            void setLast(listE*);
                
            void setNext(listE*);

            };

            #endif 
            PHP-Code:
            #include "listE.h"

            //Konstruktor
            listE::listE(int xlistEnlistEl){
                
            data=x;
                
            next=n;
                
            last=l;
            }

            listE::listE(int xlistEn){
                
            data=x;
                
            next=n;
                
            last=NULL;
            }

            listE::listE(int x){
                
            data=x;
                
            next=NULL;
                
            last=NULL;
            }

            listE::listE(void){
                
            data=0;
                
            next=NULL;
                
            last=NULL;
            }

            //Destruktor
            listE::~listE(){
                
            //Speicher freigeben
            }

            //Funktionen

            int listE::getData(){
                return 
            data;
            }

            listElistE::getLast(){
                return 
            last;
            }

            listElistE::getNext(){
                return 
            next;
            }

            void listE::setData(int x){
                
            data=x;
            }

            void listE::setLast(listEl){
                
            last=l;
            }

            void listE::setNext(listEn){
                
            next=n;

            So muss deine Liste aussehen, damit sie funktioniert.

            Im Übrigen solltest du soetwas nie machen!

            PHP-Code:
            void listE::setNext(listEnext){
                
            next=next;

            Das kann nicht funktionieren, weil du hier dieselbe Variable zuweist! Entweder du nennst die beiden Variablen unterschiedlich oder du schreibst.

            PHP-Code:
            void listE::setNext(listEnext){
                
            this->next=next;

            Den Rest müsstest du nun auch allein problemlos programmieren können.

            Gruß,
            GAGA
            Zuletzt geändert von GAGA; 06.01.2012, 17:26.

            Kommentar


            • #7
              Fertig

              Danke für dein tolles Angagement!
              so düfte alles stimmen. Speicherlecks sollten auch keine da sein. Ist ja fast 100% dein Code von daher...

              main.cpp:
              Code:
              #include <iostream>
              #include <string>
              
              #include "list.h"
              
              using namespace std;
              
              int main(){
              	//Ausgabe
              	cout << "Liste start!" << endl;
              
              	list* l = new list();
              	
              	cout << "Liste-Length: " << l->getLength() << endl;
              	
              	for(int i=0; i<10; ++i){ l->add(i); }
              
              	cout << "Liste-Length: " << l->getLength() << endl;
              
              	l->del(0);
              	l->del(0);
              	l->ins(3,23);
              	l->ins(0,42);
              
              	for(int i=0; i<10; ++i){ cout << "i: " << i << " Liste: " << l->get(i)->getData() << endl; }
              
              	delete(l);
              
              	//Warten
              	system("pause");
              }
              listE.h:
              Code:
              #pragma once
              
              class listE{
              
              private:
              	int data;
              	listE* last;
              	listE* next;
              
              public:
              	//Konstruktor
              	listE(int);
              	listE(void);
              
              	//Destruktor
              	~listE(void);
              
              	//Funktionen
              	int getData();
              	listE* getLast();
              	listE* getNext();
              
              	void setData(int);
              	void setLast(listE*);
              	void setNext(listE*);
              
              };
              listE.cpp:
              Code:
              #include "listE.h"
              
              //Konstruktor
              listE::listE(int x){
              	data=x;
              	next=0;
              	last=0;
              }
              
              listE::listE(void){
              	data=0;
              	next=0;
              	last=0;
              }
              
              //Destruktor
              listE::~listE(){
              	//leer
              }
              
              //Funktionen
              
              int listE::getData(){ return data; }
              
              listE* listE::getLast(){ return last; }
              
              listE* listE::getNext(){ return next; }
              
              void listE::setData(int x){ data=x; }
              
              void listE::setLast(listE* l){ last=l; }
              
              void listE::setNext(listE* n){ next=n; }
              list.h:
              Code:
              #pragma once
              
              #include "listE.h"
              
              class list{
              
              private:
              	int length;
              	listE* start;
              	listE* end;
              
              public:
              	//Konstruktor
              	list(void);
              
              	//Destruktor
              	~list(void);
              
              	//Funktionen
              	int getLength();
              	listE* get(int);
              	void add(int);
              	void add(listE*);
              	void ins(int, listE*);
              	void ins(int, int);
              	void clear();
              	void del(int);
              };
              list.cpp:
              Code:
              #include "list.h"
              
              //Kontruktor
              list::list(){
              	length=0;
              	start=0;
              	end=0;
              }
              
              //Destruktor
              list::~list(void){
              	//Speicher freigeben
              	clear();
              }
              
              //Funktionen
              int list::getLength(){
              	return length;
              }
              
              listE* list::get(int index){
              	if(length<0){
              		return 0;
              	}
              	else if(index<length){
              		listE* tmp = start;
              		//Position suchen
              		for(int i=0; i<index; ++i){ tmp = tmp->getNext(); }
              		return tmp;
              	}
              }
              
              void list::add(int x){
              	listE* neu = new listE(x);
              	add(neu);
              }
              
              void list::add(listE* neu){
              	if(length>=0){
              		//Erstes Element
              		if(length==0){
              			start=neu;
              			end=neu;
              			neu->setLast(0);
              			neu->setNext(0);
              		}
              		//Sonst hinten anfügen
              		else{
              			end->setNext(neu);
              			neu->setLast(end);
              			neu->setNext(0);
              			end=neu;
              		}
              		++length;
              	}
              }
              
              void list::ins(int index, int x){
              	listE* neu = new listE(x);
              	ins(index,neu);
              }
              
              void list::ins(int index, listE* neu){
              	if(index>=0 && index<=length){
              		//Vorne einfügen
              		if(index==0){
              			start->setLast(neu);
              			neu->setNext(start);
              			neu->setLast(0);
              			start=neu;
              		}
              		//Hinten anfügen
              		else if(index==length){ add(neu); }
              		//Zwischendrin einfügen
              		else{
              			listE* tmp = get(index);
              			tmp->getLast()->setNext(neu);
              			neu->setLast(tmp->getLast());
              			neu->setNext(tmp);
              			tmp->setLast(neu);
              		}
              		++length;
              	}
              }
              
              void list::clear(){
              	//Liste leeren
              	for(int i=0; i<length; ++i){ del(0); }
              }
              
              void list::del(int index){
              	if(index<length && index>=0){
              		if(length==1 && index==0){
              			delete(start);
              			start=0;
              			end=0;
              		}
              		//Erstes Element löschen
              		else if(index==0){
              			listE* tmp = start->getNext();
              			tmp->setLast(0);
              			delete(start);
              			start=tmp;
              		}
              		//Letztes Element löschen
              		else if(index==length-1){
              			listE* tmp = end->getLast();
              			tmp->setNext(0);
              			delete(end);
              			end=tmp;
              		}
              		//Beliebiges Element löschen
              		else{
              			listE* tmp = get(index);
              			tmp->getNext()->setLast(tmp->getLast());
              			tmp->getLast()->setNext(tmp->getNext());
              			delete(tmp);
              		}
              		--length;
              	}
              }
              so hoffe das hilft noch anderen. Somit bin ich hier Fertig!

              Kommentar


              • #8
                @maxPetersen67: kleiner Tipp. Bei zeigern ist es immer besser NULL statt 0 zu schreiben. ist zwar theoretisch dasselbe, aber semantisch einleuchtender.

                Danke Jungs, dafür das ihr euren Code hier hochgeladen habt. Hilft bestimmt auch anderes usern!!

                Kommentar


                • #9
                  Hallo Richi,

                  ich werde die Programmteile demnächst in deinen Thread verschieben.

                  Gruß,
                  GAGA

                  Kommentar


                  • #10
                    Zitat von R. Fischer Beitrag anzeigen
                    @maxPetersen67: kleiner Tipp. Bei zeigern ist es immer besser NULL statt 0 zu schreiben. ist zwar theoretisch dasselbe, aber semantisch einleuchtender.
                    Mit der Aussage wäre ich vorsichtig, immerhin sieht es selbst "Mr. C++" anders http://www.stroustrup.com/bs_faq2.html#null

                    Kommentar


                    • #11
                      Ich kann die Datei nicht downloaden, ich habe irgendwie keine Rechte.

                      Mein seite von casino https://777spielen.com/beste-casino-apps/ !!! Protest

                      Kommentar

                      Lädt...
                      X