class intlist
{
public:
int getcount (void);
void init();
int additem (int );
int getitem(int );
private:
int count;
int *ilist;
};

Schreiben Sie die Klassendefinition als Klassenvorlage so um, dass auch andere Variablentypen (z.B. insbesondere float) verarbeitet werden können. Verwenden Sie das Token T.

Meine Lösung:

template<class T>
class list
{
public:
int getcount(void);
void init();
int additem(T&);
int getitem(T&);
private:
int count;
int *ilist;
};

Habe leider keine Lösung zu der Aufgabe und bin mir nicht sicher, dass meine Ergebnis richtig ist. Wäre euch für eure Hilfe sehr dankbar.
Gruß mila10

oh da war jemand schneller...

Irgendwie finde ich das ziemlich merkwürdig. Das passiert so oft! Die Frage stand 40 Minuten im Raum und rtur und ich schreiben fast gleichzeitig eine Antwort. Komisch

template<class T>
class list
{
public:
int getcount(void);
void init();
int additem(T&);
T& getitem(int);
private:
int count;
T *ilist;
};

bla bla

öhm irgendwie vermisse ich hier Destruktor, Copykonstruktor und die Überladung des =-Operators (ich gehe mal stark davon aus, dass du die brauchst für dein T * ilist) und statt der getitem-Methode wäre außerdem eine (zusätzliche) Überladung des []-Operators hübscher

Das war aber nicht in der Aufgabe gefordert wenn ich richtig sehe. Recht hast du natürlich, aber ich glaube wir sollten niemanden fürs erste Überfordern

cu André

template<class T>
class dynamic_array			// list passt nicht ganz. 
							// Eine list hat in der Informatik eine
							// etwas andere Bedeutung.
{
public:
	dynamic_array();		// Anstelle von void init.
	~dynamic_array();		// m_data muss wieder freigegeben 
					// werden!
public:
	// - std::size_t weil es der Datentyp des Standards für Größen ist.
	// - const, da du nichts am Objekt veränderst
	// - inline, da du nur eine Variable zurückgibst.
	std::size_t	size() const { return m_size; } 

public:
	// - push_back um es Leuten, die mit dem Standardarbeiten leichter
	//	 zu machen. Vgl. std::vector
	// - std::size_t, da der Index niemals negativ ist.
	// - T const&, da man mit Kopien arbeitet, damit der Aufrufer sich
	//   nicht darum kümmern muss ob das hinzugefügte Objekt noch gültig
	//	 ist.
	std::size_t push_back(T const&); 
	// - at um es Leuten, die mit dem Standardarbeiten leichter
	//	 zu machen. Vgl. std::vector
	// - eine const und eine nicht const Version um übergabe einer const 
	//   Ref. usw. möglich zu machen. 
	// - Bei out_of_range Exception werfen!
	T& at(std::size_t);	
	T const& at(std::size_t) const;
	// - Einen Index-Operator um einfachen Zugriff wie bei normalen Array
	//	 zu ermöglichen.
	// - Ebenfalls const. Version und nicht-const. Version.
	// - KEINE out_of_range Exception werfen! (vgl. std::vector)
	T& operator[](std::size_t); 
	T const& operator[](std::size_t) const; 

private:
	std::size_t m_size;	// std::size_t, da die Größe nicht negativ sein kann.
	T*			m_data;
};