3. ganz schlimmer fehler!!!

ganz schlimmer fehler!!!

  • D

    xxx

    0
  • ?

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

    0
  • D

    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.

    0
  • E

    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...

    0
  • D

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

    0
  • ?

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

    0
  • ?

    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 😕

    0
  • M

    Include-Guards vergessen?

    0
  • B

    Hast du Include-Guards verwendet?

    EDIT: War wohl einer schneller als ich...

    0
  • ?

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

    0
  • M

    GV schrieb:

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

    *PATSCH*

    0
  • ?

    Was heisst PATSCH ?

    0
  • ?

    Was heisst PATSCH ?

    0
  • M

    GV schrieb:

    Was heisst PATSCH ?

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

    0
  • ?

    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.

    0
  • ?

    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.

    0
  • M

    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.

    0
  • L

    1. Deklaration: template <typname T>
      const T& irgendwas (const T&, const T&);
    2. Definition:
      template <typname T>
      inline const T& irgendwas (const T& a, const T& b)
      {
      a = a+b;
      return a;
      }
    3. 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.

    0
  • ?

    mein compiler ist beim letzten versuch abgestürzt 😞
    ich poste jetzt einfach mal wie aussieht(im mom.) und ihr wie es eurer meinung nach aussehen muss. außerdem ist jetzt noch ein guter zeitpunkt zu sagen (@linux) ich hab noch NIE mit export gearbeitet. 🤡

    #ifdef HAVE_CONFIG_H
#include <config.h>
#endif

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

using namespace std;

int main(int argc, char *argv[])
{
  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();

  return EXIT_SUCCESS;
}

    #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;
};
#include "matrix.cpp"

    (ich glaub übrigens nicht das die umbenennung zu *.inl nötig ist...

    #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];
}

    ursprünglich wollt ich mit der klasse mal versuchen ein neuronales netz zu schreiben... hab zwar keine ahnung wie, aber in den sommerferien wirds schon irgendwann klappen 😃

    0
  • ?

    betrachtet mal in der main(include sektion) das *.cpp als *.h) BITTE-
    es ist aus eurem gedächtnis gerichen-->HYPNOTISCH 😮

    0
Anmelden zum Antworten