class no1{
 private:
  int i;
 public:
  no1(){
  i = 10;
 }

 inline get_i()
   return this->i;

};

class no2{
 private:
  int iMerken;
 public:
  rechne(int i, int iMerke)
    this->iMerke = i+iMerke;
};

So ungefähr am besten das ich das nicht als Parameter erstellen muss sondern das ich da immer vollen Zugriff hab. Also nur beim erstellen angeben muss.
Das int ist im meinen Projekt eine struct also ein bisschen größer der ganze Code.

#include <iostream>
#include <conio.h>

using namespace std;

struct Element{
	int data;
	Element *prev;
};

class myList{
	private:
		Element *first;
		Element *last;

	public:
		myList(){
			first = new Element;
			last = first;
			first[0].data = 0;
		}

		void push_back(int in){
			last = new Element;
			last[0].data = in;
			first[0].prev = this->last;
		}

		void show(){
			cout << last[0].data << endl;
		}

};

class it{
	private:
		Element Aktuell;
	public:

};

int main(){

	myList list;

	for(int i = 1; i < 200; i++){
		list.push_back(i);
		list.show();
	}

	_getch();
	return 0;
}

CraftPlorer schrieb:

#include <iostream>

using namespace std;

struct Element{
	int data;
	Element *prev; // warum heiszt das Ding prev?
};

class myList{
	private:
		Element *first;
		Element *last;

	public:
		myList(){
			first = new Element; // warum hat eine leere Liste ein Element?
			last = first;
			first[0].data = 0; // brrr ... first->data !?
		}

        void push_back(int in){
            last = new Element;
            last[0].data = in; // siehe oben.
            first[0].prev = this->last; // Nach push_back() ist die liste kaputt. Wohin zeigt last->prev?
        }

        void show(){ // eine funktion, die nur das letzte element ausgibt?
            cout << last[0].data << endl; // siehe oben.
        }

};

Warum dereferenzierst du immer mitm Indexoperator anstatt mit dem Dereferenzierungsoperator?
Warum hat das Ding keinen Destruktor?
Was ist an push_back() kaputt. Wie geht's richtig?
Wie greifst auf den Wert des i ten Listenelements zu? Lesend und schreibend? Mal ohne Iterator?
Plötzlich kommst d'rauf, du hättest gerne auch eine myList für float - was tust?

//edit: tagsoup ...

Also da hab ich es so gelernt, dass man einen Kopfknoten und einen Endknoten hat, die beide keine Daten enthalten.

Wieso sollen Wurzel und Ende keine Daten tragen?

Der Tobi schrieb:

Jeder Knoten speichert nur einen Zeiger zu seinem Nachfolger und einen Zeiger/Referenz zu den Daten.

Warum "Zeiger/Referenz zu den Daten" und nicht gleich die Daten selbst?

Der Tobi schrieb:

Wenn du willst kann ich ja mal meine Implementierung einer verketteten Liste posten, [...] So wie du das versuchst wird das keine Liste, sondern allerhöchstens ein C-Abklatsch mit bisschen new/delete.

Zeig' mal.

#include <iostream>
#include "list.h"
//main.cpp

int main()
{
    List list;

    for (int i = 0; i<1000; ++i)
        list.insert(i);

    list.print();
}

//list.h
#include "node.h"
#include "startnode.h"
#include "endnode.h"

class List
{
    Startnode* _start;

    List(const List&);
    List& operator=(const List&);

    public:

        List();

        ~List();

        void insert(const Data&);

        void print() const;
};

#include "list.h"
#include <iostream>
//list.cpp
List::List()
    : _start(new Startnode(new Endnode))
{
}

List::~List()
{
    delete _start;
}

void List::insert(const Data& dat)
{
    _start->insert(dat);
}

void List::print() const
{
    _start->print();
}

//startnode.h
#include "node.h"

class Startnode : public bNode
{
    bNode* _next;

    Startnode(const Startnode&);
    const Startnode& operator=(const Startnode&);

    public:

        Startnode(bNode*);

        ~Startnode();

        bool insert(const Data&);

        void print() const {_next->print();}
};

#include "startnode.h"
#include <iostream>
//startnode.cpp
Startnode::Startnode(bNode* next)
           : _next(next)
{
}

Startnode::~Startnode()
{
    delete _next;
}

bool Startnode::insert(const Data& dat)
{
    if (!_next->insert(dat))
        _next = new Node(dat, _next);
    return true;
}

const Startnode& Startnode::operator=(const Startnode& rhs)
{
    *(this->_next) = *(rhs._next);
    return *this;
}

#include "data.h"

class bNode
{
    public:
        virtual ~bNode() {}
        virtual bool insert(const Data&) = 0;
        virtual void print() const  = 0;
};

//node.h
class Node : public bNode
{
    Data* _data;
    bNode* _next;

    const Node& operator=(const Node&);
    Node(const Node&);

    public:
        Node(const Data&, bNode*);

        ~Node();

        bool insert(const Data&);

        void print() const;
};

#include "node.h"
#include <iostream>
//node.cpp
Node::Node(const Data& dat, bNode* next)
        : _data(new Data(dat)), _next(next)
{
}

Node::~Node()
{
    delete _next;
    delete _data;
}

bool Node::insert(const Data& dat)
{
    if (!_next->insert(dat)) //if insert returns false for the next node (can only happen if next node is
        _next = new Node(dat, _next); // end node, because Node::insert always returns true) insert is
    return true; //called for the next node -> all nodes are added directly before the end node
}

void Node::print() const
{
    std::cout << "Wert: " << _data->Value() << "\n";
    _next->print();
}

//endnode.h
#include "node.h"
#include <iostream>

class Endnode : public bNode
{
    public:

        ~Endnode() {}
        bool insert(const Data& dat) {return false;}
        void print() const {}
};

//data.h
class Data
{
    int _value;

    public:
        Data(int = 0);
        ~Data();

        Data(const Data&);

        const Data& operator=(const Data&);

        bool operator<(const Data&) const;
        bool operator==(const Data&) const;
        bool operator>(const Data&) const;

        void Value(int v) {_value = v;}
        int Value() const {return _value;}
};

#include "data.h"
//data.cpp
Data::Data(int val)
        : _value(val)
{
}

Data::~Data()
{
}

Data::Data(const Data& rhs)
        : _value(rhs._value)
{
}

const Data& Data::operator=(const Data& rhs)
{
    this->_value = rhs._value;
    return *this;
}

bool Data::operator<(const Data& rhs) const
{
    return (this->_value < rhs._value);
}

bool Data::operator==(const Data& rhs) const
{
    return (this->_value == rhs._value);
}

bool Data::operator>(const Data& rhs) const
{
    return (this->_value > rhs._value);
}

Ja, jetzt wo ich es mir nochmal anschaue war die abstrakte Basisklasse doch irgendwie ein Overkill. Warte, ich setz mich nochmal ran.

2. Wie mach ich das das es nicht nur für int funktioniert? Ich meine wenn ich ein Pointer erstelle muss ich doch angeben von welchen Typ...

3. Ich bin mir ziemlich sicher das der Destructor falsch ist also das mit den löschen. Wie sieht das richtig aus?

Der Code:

#include <iostream>
#include <conio.h>

using namespace std;

struct Element{
	int data;
	Element *last;
	Element *next;
};

class myList{
	private:
		Element *current;
		Element *before;

		Element *first;
		Element *last;

		bool    _New;
	public:
		myList(){
				current   = new Element;
				first     = current;
				last      = current;
				before	  = current;

				current->last = current;
				current->next = current;
		}

                ~myList(){
		       delete [] current;
		}

		void push_back(int in){

				if(_New){
					current->data = in;
					_New = false;
				}
				current       = new Element;

				before->next  = current;
				current->data = in;
				current->last = before;
				current->next = current;
				last		  = current;

				before        = current;
		}

		void show(){

			Element *loop;
			loop = first->next;
			cout << loop->data << "		" << loop << "		" << loop->last 
			     << "		" << loop->next << endl << endl;

			do{
				loop = loop->next;
				cout << loop->data << "		" << loop << "		" << loop->last 
				 << "		" << loop->next << endl << endl;
			}while(!(loop == last));

		}
};

//class it{
//	private:
//		Element *loop;
//		Element end;
//		
//	public:
//		void insert(int end){
//			myList classList;
//			loop = classList.first;
//			for(int i = 0; i <= end; i++){
//				loop = loop->next;
//			}
//			cout << loop->data << endl;
//		}
//		
//};

int main(){

	myList list;

	for(int i = 0; i <= 100; i++){
	list.push_back(i);
	}

	list.show();

	_getch();
	return 0;
}

Wer Fehler oder Verbesserungen hat bitte mit Zitat oder Zeilennummer antworten.

Hoffe ihr könnt mir helfen.

Warum initialisierst du Klassenmember nicht?
Warum die Unmenge an Pointer?
Warum hat ein Element einen Pointer aufs Ende ( last )?
Verabschiede dich bitte von der Idee, direkt in die List einen Zeiger auf ein "aktuelles" Element ( <- was das auch immer im Kontext einer Liste sein sollte) zu halten.

vielleicht solltest du dir die Definition einer einfach verketteten Liste ansehen: Einfach verkettete Liste

// edit: Geschmacksmuster:

#include <iostream>

class list_node_t
{
	private:

		int value;
		list_node_t *next;

	public:

		list_node_t() : value(), next( nullptr ) {}
		list_node_t( int value ) : value( value ), next( nullptr ) {}

		int get_value() const { return value; }
		list_node_t* get_next() const { return next; }
		void set_next( list_node_t * const new_next ) { next = new_next; }

	private:
		list_node_t( list_node_t const &other ); // Unsere Listenknoten koennen nicht kopiert werden.
};

class list_t
{
	private:

		list_node_t *root;

	public:

		list_t() : root( nullptr ) {}

		~list_t()
		{
			std::cout << "\n~list_t()\n";
			if( root ) { // <- wenn das Ding nicht sowieso leer ist ...

				list_node_t *to_delete = root;
				list_node_t *next = nullptr;

				do {

					next = to_delete->get_next();
					std::cout << "Deleting node with value " << to_delete->get_value() << "\n";
					delete to_delete;

				} while( to_delete = next ); // solange next nicht nullptr
			}						
		}

		void push_back( int value )
		{
			std::cout << "\npush_back( " << value << " )\n";

			if( !root ) { // sonderfall: Liste ist leer.

				std::cout << "Creating root node with value " << value << '\n';
				root = new list_node_t( value );

			} else {

				list_node_t *i = root;

				for( ; i->get_next(); i = i->get_next() ) {

					std::cout << "Passed node with value " << i->get_value() << '\n';
					// Bis ans Ende laufen
				}

				std::cout << "Passed node with value " << i->get_value() << '\n';
				std::cout << "Ceating new last node with value " << value << '\n';
				i->set_next( new list_node_t( value ) ); // am letzen Element anhängen
			}
		}

		void print() const
		{
			std::cout << "\nprint()\n";

			std::size_t counter = 1;

			for( list_node_t *i = root; i; i = i->get_next(), ++counter ) {

				std::cout << "List node #" << counter << " has value " << i->get_value() << '\n';
			}
		}

	private:
		list_t( list_t const &other ); // Unsere Liste kann nicht kopiert werden.
};

int main()
{
	list_t list;

	for( int i = 1; i <= 5; ++i ) {

		list.push_back( i );
	}

	list.print();
}

Output:

push_back( 1 )
Creating root node with value 1

push_back( 2 )
Passed node with value 1
Ceating new last node with value 2

push_back( 3 )
Passed node with value 1
Passed node with value 2
Ceating new last node with value 3

push_back( 4 )
Passed node with value 1
Passed node with value 2
Passed node with value 3
Ceating new last node with value 4

push_back( 5 )
Passed node with value 1
Passed node with value 2
Passed node with value 3
Passed node with value 4
Ceating new last node with value 5

print()
List node #1 has value 1
List node #2 has value 2
List node #3 has value 3
List node #4 has value 4
List node #5 has value 5

~list_t()
Deleting node with value 1
Deleting node with value 2
Deleting node with value 3
Deleting node with value 4
Deleting node with value 5

// edit:
Reduziert aufs Wesentliche

template< typename T >
class list_t
{
	private:
		struct list_node_t
		{
			T value;
			list_node_t *next;

			list_node_t( T value ) : value( value ), next( nullptr ) {}
		} *root;

		list_t( list_t const & ); // not copyable.

	public:
		list_t() : root( nullptr ) {}

		~list_t()
		{
			if( root ) {

				list_node_t *to_delete = root;
				list_node_t *next = nullptr;

				do {				
					next = to_delete->next;
					delete to_delete;

				} while( to_delete = next );
			}						
		}

		void push_back( int value )
		{
			if( !root ) {

				root = new list_node_t( value );

			} else {

				list_node_t *i = root;				
				for( ; i->next; i = i->next );
				i->next = new list_node_t( value );
			}
		}

	friend std::ostream& operator<<( std::ostream &os, list_t< T > const &list )
	{
		std::size_t counter = 1;

		for( list_node_t *i = list.root; i; i = i->next, ++counter ) {

			os << "List node #" << counter << " has value " << i->value << '\n';
		}

		return os;
	}
};

Der Code:

#include <iostream>

using namespace std;

struct Element{
	int data;
	Element *prev;
	Element *next;
};

class myList{
	private:
		Element *current;
		Element *before;

		Element *first;
		Element *last;

		bool    _New;
	public:
		myList(){

			    _New      = true;
				current   = nullptr;
				first     = nullptr;
				last      = nullptr;
				before	  = nullptr;
		}

		~myList(){								//Hier bin ich mir nicht sicher ob alles gelöscht wird.
			if(!(first == nullptr)){
				Element *loop       = first;
				Element *to_delete  = nullptr;

				while(!(loop->next == nullptr)){
					to_delete   = loop;
					loop        = to_delete->next;
					delete to_delete;
				}
			}
		}

		void push_back(int in){

				if(_New){
					current       = new Element;
					current->data = in;
					current->prev = nullptr;
					current->next = nullptr;
					first		  = current;
					last		  = current;
					before		  = current;
					_New		  = false;
				}else{
				current		  = new Element;

				before->next  = current;
				current->data = in;
				current->prev = before;
				current->next = nullptr;
				last		  = current;

				before        = current;
				}
		}

		void show(){

			Element *loop = first;

			if(!(loop == nullptr)){
				Element *loop = first;
				cout << loop->data << "		" << loop << "		" << loop->prev 
					 << "		" << loop->next << endl << endl;

				while(!(loop->next == nullptr)){
					loop = loop->next;
					cout << loop->data << "		" << loop << "		" << loop->prev 
					 << "		" << loop->next << endl << endl;
				}
			}else{
				cout << "List empty!" << endl;
			}

	}
};

int main(){

	myList list;

	for(int i = 0; i <= 10; i++){
	list.push_back(i);
	}

	list.show();

	myList list2;
	list2.show();
	list2.push_back(25155);
	list2.show();
	list.show();
	cin.get();
	return 0;
}

Noch so ne Frage nebenbei kann man das hier im Forum auch so machen das man ein Text(Quellcode) ein und ausklappen kann also auf ein Button drückt und dann wird der erst angezeigt?

Aber ich verstehe schon was du meinst, aber nur um Libs zu nutzen brauch man kein Studium zu machen. Außerdem sollte auch kein Informatiker nur Libs zusammen klatschen, dafür ist er einfach zu überqualifiziert. Diese Leute sollten z.B. eigenen Sprachen entwerfen, beraten, sehr große Projekte planen und nur ganz wenig selbst Hand anlegen. Ein Architekt käme auch nicht auf die Idee jetzt mit Zementkelle und Ziegelsteine hantieren zu wollen.