Zuerst der Header.

typedef int Element;

class List
{
public:
	List();			//Konstruktor; erzeugt leere Liste
	~List();		//Destruktor

	int insert(int pos, Element x);
	//Fügt x in Liste an Position Pos ein. Elemente danach werden um 1 Pos nach rechts verschoben.
	//Liefert 0 bei falscher Position (pos < 0, oder pos > length); sonst 1.

	int del(int pos);
	//Löscht Element an Position pos. Elemente danach werden um 1 pos nach links verschoben.
	//Liefert 0 bei falscher Position (pos < 0, oder pos >= length); sonst 1.

	int get(int pos, Element& x)const;
	//Liefert Element x an Position x.
	//Liefert 0 bei falscher Position (pos < 0, oder pos >= length); sonst 1.

	int assign(int pos, Element x);
	//Weist Element x an Position pos zu.
	//Liefert 0 bei falscher Position (pos < 0, oder pos >= length); sonst 1.

	int length() const {return n;}
	//liefert Anzahl der Elemente.

private:
	Element* a; //Liste als dynamisches Feld
	int n;		//Anzahl der Elemente
	int gr;		//Feldgröße von a

};

dann das Hauptprogram

#include <iostream>
#include "listasarray.h"

using namespace std;

//Definition von printlist...
int printList(List list1)
{

		Element Erg;
		int lang = 0;

		//List list;	

		for(int i = 0; i < 10; i++)
			{
			list1.get(i,Erg);
			lang = list1.length();
			cout << "i" << lang;
			cout << "i." << i << "Element:" << i << Erg;
			}
		return 0;
	}

int main()
{
	List list;

	list.insert(0,1);
	printList(list);
	cout << endl;
		// 1 |

	list.insert(1,10);
	printList(list);
	cout << endl;
	// 1 | 10 |

	list.insert(1,2);
	printList(list);
	cout << endl;
	// 1 | 2 | 10 |

	list.assign(1,5);
	printList(list);
	cout << endl;
	// 1 | 5 | 10 |

	list.del(0);
	printList(list);
	cout << endl;
	// 5 | 10 |
}

Ich habe nun schon etliche Dinge probiert, bekomme es wegen dem Fehler aber nicht zum laufen und auch die online Hilfe sagt mir da sehr wenig. Wäre super wenn einer den erlösenden Tip hätte.

Und wo hast Du die Methoden der Klasse implementiert???

Die aus der List Klasse? Sind die nicht alle drin?

Jochen Kalmbach schrieb:

Und wo hast Du die Methoden der Klasse implementiert???

Die aus der List Klasse? Sind die nicht alle drin?

Nicht bei selbst deklarierten Klassen

Falls du std::list<> meinst, das ist ne eingebaute Klasse. Aber wenn du eine Klasse deklarierst musst du auch deren Methoden definieren

BR

int insert(int pos, Element x);
	//Fügt x in Liste an Position Pos ein. Elemente danach werden um 1 Pos nach rechts verschoben.
	//Liefert 0 bei falscher Position (pos < 0, oder pos > length); sonst 1.

Nein, der Compiler kann kein Deutsch, er generiert Dir den gewünschten Code nicht selbsttätig

Aber nichtsdestotrotz würde ich gerne wissen was ich gegen das nicht aufgelöste Symbol machen kann. Man liest immer das irgendwelche includes fehlen etc., aber bei diesem kurzen code kann doch nicht noch was fehlen. Wie kriege ich das weg?

Achja, Deine Funktion insert z.B. müsste wie folgt ausgeschrieben werden:

int List::insert(int pos, Element x) {
  // Code
}

Wie schon mehrmals gesagt musst Du alle Funktionen auch implementieren, denn was nicht da ist kann der Linker auch nicht finden. Da sicher niemand deine Klasse ausprogrammiert und in die Standardbibliothek gepackt hat, nutzen weitere Includes herzlich wenig. Wie gesagt, der Compiler kann kein Deutsch sondern nur C++, Deine Kommentare reichen ihm nicht!

Achja, Deine Funktion insert z.B. müsste wie folgt ausgeschrieben werden:

int List::insert(int pos, Element x) {
  // Code
}

Achso und dann ist das externe Symbol auch weg? ICh weiß schon was ihr mir sagen wollt, konnte aber allgemein mit der Fehlermerldung nichts anfangen. Also meint das im Endeffekt nur das die Implementierung fehlt?

WIe gehabt erst die hpp

#ifndef LIST_ARRAY
#define LIST_ARRAY     

#include <iostream>
using namespace std;

template<class T0>
class List
{
	private:
		static const int blockGr; //number of elements in the list for which storage is allocated in one step
		T0 * a;				//list as dynamic array
		int n;				//number of elements in the list
		int gr;				//number of element in the list for which storage is allocated up to now

	public:
		List();								//	constructor, generates empty list
        List(const List &);					// copy constructor 
		~List();							//	destructor

		int length(void) const;				//returns length of list
		bool insert(int pos, const T0 & x);	//inserts x at position pos, shifts the following elements
											//returns 0, if pos dos not make sense, otherwise 1
		bool del(int pos);					//deletes element at position pos, shifts the following elements
											//returns 0, if pos does not make sense, otherwise 1
		bool get(int pos, T0 & x) const;	//x becomes a copy of the element at position pos
											//returns 0, if pos does not make sense, otherwise 1
		bool assign(int pos, const T0 & x);	//assigns x to position pos
											//returns 0, if pos does not make sense, otherwise 1
		List & operator=(const List &);     
		bool operator==(const List &) const;
        friend ostream & operator<< (ostream &, const List<T0> &);	//List output 
};

#endif

/***************************************************************************************************************/
template<class T0>
const int List<T0>::blockGr=100;

template<class T0>
List<T0>::List()
{
	a	=	new	T0[blockGr];
	gr	=	blockGr;
	n	=	0;
}

template<class T0>
List<T0>::List(const List<T0> & vorl)
{
	n=vorl.n;
	gr=vorl.gr;
	a = new T0[gr];
	for	(int i=0;i<n;i++)
		a[i]=vorl.a[i];
}                              

template<class T0>
List<T0>::~List() 
{
	delete [] a;
}

template<class T0>
inline int List<T0>::length(void) const {return n;}

template<class T0>
bool List<T0>::insert(int pos, const T0 & x)
{
	if ((pos<0)||(pos>n))
		return	0;	

	int i;
	if	(n	>=	gr)	//	storage aquired
	{
		T0*	h=new T0[gr+blockGr];
		for (i=0;i<gr;i++)
			h[i]=a[i];
		delete	[]	a;
		a=h;
		gr	+=	blockGr;
	}
	for	(i=n;i>pos;i--)
		a[i]=a[i-1];
	a[pos]=x;
	n++;
	return	1;
}

template<class T0>
bool List<T0>::del(int pos)
{
	if ((pos<0)||(pos>=n))
		return	0;		

	int i;
	for	(i=pos;i<n;i++)
		a[i]=a[i+1];
	n--;
	if	(n	<= gr-blockGr)	//	storage superfluous
	{
		T0*	h=new T0[gr-blockGr];
		for (i=0;i<gr;i++)
			h[i]=a[i];
		delete	[]	a;
		a=h;
		gr	-=	blockGr;
	}
	return	1;
}

template<class T0>
bool List<T0>::get(int pos, T0 & x) const
{
	if ((pos<0)||(pos>=n))
		return 0;		
	x=a[pos];
	return 1;
}

template<class T0>
bool List<T0>::assign(int pos, const T0 & x)
{
	if ((pos<0)||(pos>=n))
		return	0;		
	a[pos]=x;
	return	1;
}

template<class T0>
List<T0> & List<T0>::operator = (const List<T0> & vorl)
{
	if (this != &vorl)
	{
		n=vorl.n;
		gr=vorl.gr;
		delete a;
		a = new T0[gr];
		for	(int i=0;i<n;i++)
			a[i]=vorl.a[i];
	}
	return *this;
}

template<class T0>
bool List<T0>::operator==(const List<T0> & rs) const
{
	if (n!=rs.n)
		return 0;
	for	(int i=0;i<n;i++)
	{
		if (a[i]!=rs.a[i])
			return 0;
	}
	return 1;
}

template<class T0>
ostream & operator<< (ostream &os, const List<T0> &rs)
{
	int i;
	for	(i=0;i<rs.n;i++)
		os << i+1 << ".Listenelement:" << endl << "\t\t\t\t" << rs.a[i] << endl;
	os << "end of list" << endl;
	return os;
}

und dann die cpp

#include "List_asArray.hpp"
#include <iostream>

using namespace std;

void main()
{
	List<int> list1, list2;
	int x[3],i;

	cout << "list1:" << endl << list1;
	cout << "List length: " << list1.length() << endl;

	list1.insert(0,1);
	cout << endl << "list1:" << endl << list1 << endl;	//	1	|

	list1.insert(1,10);
	cout << "list1:" << endl << list1 << endl;	//	1	|	10	|

	list1.insert(1,2);
	cout << "list1:" << endl << list1 << endl;	//	1	|	2	|	10	|

	for (i=0;i<3;i++)
	{
		list1.get(i,x[i]);
		cout << "x[" << i << "]=" << x[i] << endl;
	}

	list2=list1;
	cout << endl << "list2:" << endl << list2 << endl;	//	1	|	2	|	10	|

	if (list2==list1)
		cout << endl << "list2==list1" << endl << endl;

	list1.assign(1,5);
	cout << "list1:" << endl << list1 << endl;	//	1	|	5	|	10	|

	list1.del(0);
	cout << "list1:" << endl << list1 << endl;	//	5	|	10	|

	cout << "List1 length: " << list1.length() << endl;
}

Kann mir bitte jemand helfen was ich tuen muss damit es lauffähig wird? Die ganze rumprogrammiererei macht für mich wenig Sinn wenn es eh nicht läuft. Der Code sollte mit nem VS6.0 auf jeden Fall laufen, aber da das kostenpflichtig ist habe ich das nicht drauf.

#include "foo.inl"

Diese Vorgehensweise ist aber ein Sonderfall für Templates. Thema: die aktuelle Compilergeneration und ihr Problem mit export