Ergebnis 1 bis 10 von 10

Thema: Verkettete Liste

  1. #1
    maxPetersen67
    Gast

    Frage 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. #2
    CodePlanet Staff Avatar von GAGA
    Registriert seit
    11.09.2005
    Beiträge
    166

    Standard

    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.

    Klicken Sie auf die Grafik für eine größere Ansicht

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

    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
    Geändert von GAGA (06.01.2012 um 02:50 Uhr)

  3. #3
    maxPetersen67
    Gast

    Standard

    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
    Klicken Sie auf die Grafik für eine größere Ansicht

Name:	cpp0.jpg
Hits:	1
Größe:	35,1 KB
ID:	136
    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...

  4. #4
    CodePlanet Staff Avatar von GAGA
    Registriert seit
    11.09.2005
    Beiträge
    166

    Standard

    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:

    Klicken Sie auf die Grafik für eine größere Ansicht

Name:	610px-Doubly-linked-list.svg.png
Hits:	0
Größe:	3,9 KB
ID:	137

    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
    Geändert von GAGA (06.01.2012 um 15:30 Uhr)

  5. #5
    maxPetersen67
    Gast

    Standard

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

  6. #6
    CodePlanet Staff Avatar von GAGA
    Registriert seit
    11.09.2005
    Beiträge
    166

    Standard

    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
    Geändert von GAGA (06.01.2012 um 17:26 Uhr)

  7. #7
    maxPetersen67
    Gast

    Lächeln 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!

  8. #8
    Neuer Benutzer Avatar von R. Fischer
    Registriert seit
    23.11.2005
    Beiträge
    23

    Standard

    @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!!

  9. #9
    CodePlanet Staff Avatar von GAGA
    Registriert seit
    11.09.2005
    Beiträge
    166

    Standard

    Hallo Richi,

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

    Gruß,
    GAGA

  10. #10
    Neuer Benutzer
    Registriert seit
    11.12.2005
    Beiträge
    2

    Standard

    Zitat 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

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •