ganz schlimmer fehler!!!

das bekomm ich:

main.cpp:(.text+0x21): undefined reference to `matrix<int>::matrix(unsigned int)'
main.cpp:(.text+0x2c): undefined reference to `matrix<int>::setze_in_matrix(int*, int)'
main.cpp:(.text+0x35): undefined reference to `matrix<int>::ausgabe_matrix()'
main.cpp:(.text+0x41): undefined reference to `matrix<int>::~matrix()'
main.cpp:(.text+0x53): undefined reference to `matrix<int>::~matrix()'

bei dieser wunderbaren klasse:

#include <iostream>
#include <cstdlib>

using namespace std;

template <class T>
class matrix
{
	public:
		matrix(unsigned int z); //eine dimension
		matrix(unsigned int z, unsigned int s);  //zwei dimemsionen
		//matrix(int, int, int);  //noch nicht
		~matrix();

		void ausgabe_matrix();

		void setze_in_matrix(T *feld); //schiebt hinten rein(matrix)
		void setze_in_matrix(T *feld, int pos_z);  //für eindim array
		void setze_in_matrix(T *feld, int pos_z, int pos_s); //für zweidim matrix

		void fuege_array_ein(T *array);

	private:
		T *matrix_eindim;
		T **matrix_zweidim;
		//T ***matrix_dreidim;

		unsigned int zeilen_matr;
		unsigned int spalten_matr;

		unsigned int index_z_eindim;  //damit verwechlungen ausgeschlossen sind
		unsigned int index_z_zweidim;
		unsigned int index_s_zweidim;
};

dabei ha ich alles sauber implementiert (naja nicht ganz alles ) :

#include <iostream>
#include <cstdlib>
#include "matrix.h"

using namespace std;

template <class T>
matrix<T>::matrix(unsigned int zeilen)
{
	matrix_eindim = new T[zeilen];
	zeilen_matr = zeilen;
}

template <class T>
matrix<T>::matrix(unsigned int zeilen, unsigned int spalten)
{
	matrix_zweidim = new T*[zeilen];
	for(int i=0; i < zeilen; i++)
		matrix_zweidim[i] = new T[spalten];
	zeilen_matr = zeilen;
	spalten_matr = spalten;
}

template <class T>
matrix<T>::~matrix()
{
	delete matrix_eindim;
	delete matrix_zweidim;
	//delete matrix_dreidim;
}

template <class T>
void matrix<T>::ausgabe_matrix()
{
	for(int i = 0; i < zeilen_matr; i++)
		cout<< "Position " << i << ": " << matrix_eindim[i] << endl;
}

template <class T>
void matrix<T>::setze_in_matrix(T *feld)
{
	int feld_zeilen = sizeof(feld) / sizeof(feld[0]);
	for(; index_z_eindim < feld_zeilen; index_z_eindim++)
		matrix_eindim[index_z_eindim] = feld[index_z_eindim];
}

das ist in der main:

int a[] = {1,2,3,4,5,6,7,8,9,8,7,6,5,4,3};

  matrix<int> mat(15);
  mat.setze_in_matrix(a, 15);
  mat.ausgabe_matrix();

mal im ernst, was will mir der fehler sagen?

Turing

Habe den Code nur mal überflogen...

War das nicht mal so, dass man template-deklarationen und definitionen in eine Datei schreiben muss?

Ausserdem tun deine destruktoren extrem in den augen aua : )
Besser mit delete [] Speicher freigeben

Gruss

turing

dali

Turing schrieb:

Habe den Code nur mal überflogen...

War das nicht mal so, dass man template-deklarationen und definitionen in eine Datei schreiben muss?

Exakt daran wird es liegen. Du kannst auch wenn die Definition von der Deklaration trennen willst inline Files benutzen ansonsten alles in den Header.

dali

xxx

@turing: gut der destruktor ist wohl nicht ganz gelungen...

zu den templates: ich muss gestehen ich hab sie das erste mal verwendet, aber ich kann mir das nicht ganz vorstellen denn ich hab sonn pdf gefunden und da stand folgendes:

Nochmals die Template-Klasse Stack, diesmal aber mit
Trennung von Deklaration und Definition:

template <class T>
class Stack {
private:
  T* inhalt;
  int index;
  int size;
public:
  Stack(int s);
  void push(Type item);
  T top() const;
  void pop();
};

und jetzt ratet mal wie die implem. ausschaut!:

#include "stack.h"
using namespace std;
// Achtung: nicht Stack::Stack(int s)!
template <class T>
Stack<T>::Stack(int s):index(-1),size(s)
{
  inhalt = new T[size];
}
template <class T>
void Stack<T>::push(T item) {
  if(index<size) {inhalt[++index]=item;}
}
template <class T>
T Stack<T>::top() const {
  if (index>=0) {return inhalt[index];}
}
template <class T>
void Stack<Type>::pop() {
  if (index >= 0) {index--;}
}

--------------------------------------------------------------------------
denn sowas will ich nicht machen:

template <class T>
class Stack {
private:
T* inhalt; // Datenbereich des Stacks
int index, size; // Aktueller Index, Grösse des Stacks
public:
Stack(int s): index(-1), size(s) { // Constructor
inhalt = new T[size]; // Stack als Array implementiert
}
void push(T item) { // Ein Element auf den Stack "pushen"
if (index < (size - 1)) {
inhalt[++index] = item;
}
}
T top() const { // Ein Element vom Stack lesen
if (index >= 0) {return inhalt[index];}
}
void pop() { // Ein Element auf dem Stack löschen
if (index >= 0) {--index;}
}

aber das inlinen hört sich interessant an, ich hab inline funktionen bisher nur für konstruktor implementationen benutzt, könntest du trotzdem mal ein beispiel anhand einer memberfunktion machen?

dali

Mit inline meine ich einfach du legst ne Datei an die ne Endung inl anstatt cpp hat. Die *.inl Datei kannst du dann ganz normal benutzen wie ne cpp datei nur eben dass du sie nach der klasse gleich includieren musst.

also die h Datei sieht dann so aus:

template <class T>
class Abc {
    // ....
    void Foo();
};
#include "abc.inl"

und die abc.inl file dann so wie du sie eh schon gemacht hast.

energyzer

exigoner schrieb:

zu den templates: ich muss gestehen ich hab sie das erste mal verwendet, aber ich kann mir das nicht ganz vorstellen denn ich hab sonn pdf gefunden und da stand folgendes:

Es ist eine etwas nervige und umständliche Sache an C++. Allerdings existiert
die Lösung wohl schon in Form des export Schlüsselwortes. Großes Problem: Kaum
ein Compiler unterstützts...

dali

Darum würd ich dir auch raten das Schlüsselwort nicht zu verwenden..

wenn das alles ist... werds morgen mal probieren...(müde)

meine compiler spuckt diese meldungen irgendwie

from matrix.h:36,
from main.cpp:7:
...
matrix.h:8: error: redefinition of `class matrix<T>'
matrix.h:8: error: previous definition of `class matrix<T>'
...
from matrix.h:36,
from matrix.inl:3,
...
matrix.h:8: error: redefinition of `class matrix<T>'
matrix.h:8: error: previous definition of `class matrix<T>'
...

in ner endlosschleife aus

MFK

Include-Guards vergessen?

BigBoomer

Hast du Include-Guards verwendet?

EDIT: War wohl einer schneller als ich...

#include *.cpp anstelle von #include *.h

MFK

GV schrieb:

#include *.cpp anstelle von #include *.h

*PATSCH*

Was heisst PATSCH ?

Was heisst PATSCH ?

MFK

GV schrieb:

Was heisst PATSCH ?

Das ist das Geräusch, das entsteht, wenn ich jemandem mit der Schlechter-Ratschlag-Klatsche eine verpasse

Das ist das Geräusch, das der, von MFKs Hand geführte Fisch erzeugt, wenn er auf dein Gesicht trifft. :D´

Man 'includet' keine CPPs.

Da exigoner sein Template auf zwei Dateien aufspalten will, muss die .cpp irgendwo eingebunden werden. Bei einem Template findet die Headerdatei "ihre" Implementierung nicht von allein.

MFK

GV schrieb:

Da exigoner sein Template auf zwei Dateien aufspalten will, muss die .cpp irgendwo eingebunden werden. Bei einem Template findet die Headerdatei "ihre" Implementierung nicht von allein.

Dazu hat Dali auf der ersten Seite bereits die Lösung gepostet. Das aktuelle Problem des OP hat damit nichts zu tun.

linux

Deklaration: template <typname T>
const T& irgendwas (const T&, const T&);
Definition:
template <typname T>
inline const T& irgendwas (const T& a, const T& b)
{
a = a+b;
return a;
}
Implementierung:
- Deklaration und Definition in jedem Quelltext, wo das Template
verwendet wird
- Falls Deklaration in separater Headerdatei und die Definition
in einer Extra-Implementierungsdatei erfolgen, muss der Be-
zeichner export für die Definition verwendet werden

Eine sichere Methode ist aber, die Template-Deklaration und -Def.
in eine Headerdatei zu schreiben und mit #ifndef vor mehrmaligen
Einbinden zu schützen.