MessreiheFFT(void);
~MessreiheFFT(void);
void initFuzzyfeld();
//Die anderer Methoden u Attribute hab ich weggelassen

vector<Fuzzyset*> fuzzyfeld;
};

Jedenfalls bekomme ich von Visual c++ die Fehlermeldung, ich hätte vor vector ein Semikolon vergessen, was ja nicht stimmt. Vielleicht ist noch zu sagen, dass die Basisklasse Fuzzyfeld abstrakt ist. Ich habe zum Test versucht, den gleichen Vector in einer Methode von MessreiheFFT zu instanzieren, und da hats Problemlos geklappt. Das sah so aus:
[cpp]
void MessreiheFFT::initFuzzyfeld()
{
vector<Fuzzyset*> fuzzyfeld;

FuzzyTrapez* leertrpz; //vererbte klasse von Fuzzyset
for (int i=0;i<anzmesswerte;i++)
{
fuzzyfeld.push_back(leertrpz);
}
}

Kann mir jemand sagen, wo mein Fehler ist?
Vielen Dank

Du hast den Namespace nicht angegeben: std::vector

Danke, jetzt klappts.

Hey,
ich habe wohl doch noch ein Problem mit dem vektor, welches mich echt ratlos stimmt. Und zwar kompiliert er das Programm nur manchmal:
Ich habe es in einer Version kompiliert, die funktionierte und habe dann etwas an der Klasse Fuzzyset geändert, worauf nicht mehr kompiliert wurde. Nachdem ich die Änderungen rückgangig gemacht hatte und den alten Quellcode 1 zu 1 wieder hergestellt hatte, zeigte mir der Compiler bei der deklaration des Vektors in MessreiheFFT.h an, er kenne die Klasse Fuzzyset nicht.
Die Kompilierung klappte erst wieder, nachdem ich den vekto auskommentiert, kompieliert und wieder eingebunden hatte.
Wisst ihr da weiter?

Zeig mal Code. So können wir dir nicht helfen, da wir keine Wahrsager sind. Und vergiss nicht die C++-Code Tags.

#pragma once
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include "Fuzzyset.h"

namespace settings {
    extern std::string standartpfad;
}

class MessreiheFFT
{ 
public:
        void initFuzzyfeld();
	std::vector <Fuzzyset*> fuzzyfeld;
}

Dann die zugehörigen Teile der MessreiheFFT.cpp

// MessreiheFFT.cpp

#include "MessreiheFFT.h"

void MessreiheFFT::initFuzzyfeld()
{
	FuzzyTrapez links;
	FuzzyTrapez rechts;
	FuzzyTrapez* leertrpz = new FuzzyTrapez[2];
	leertrpz[0] = links;
	leertrpz[1] = rechts;
	for (int i=0;i<anzmesswerte;i++)
	{
		fuzzyfeld.push_back(leertrpz);
	}
	fuzzyfeld[3][0].graph();
}

und die Headerdatei zu Fuzzy Trapez:

#pragma once
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
#include "MessreiheFFT.h"

class Fuzzyset
{
	friend class MessreiheFFT;
public:
	Fuzzyset(void);
	~Fuzzyset(void);
	virtual void print(void)=0;
	virtual void graph(void)=0;
            virtual void graph(char* name)=0;
};

class FuzzyLR: public Fuzzyset
{
public:
	FuzzyLR(void);
	//~FuzzyLR(void);
	void print(void);
	void graph(void);
	void graph(char* name);

};

class FuzzyTrapez: public FuzzyLR
{
public:
	FuzzyTrapez(void);
	//~FuzzyTrapez(void);

};

und die passende Fehlermeldung mit Verweis auf den Vektor:
error C2065: 'Fuzzyset': nichtdeklarierter Bezeichner

Ich habe 2 Ideen, an denen es vielleicht liegen könnte:
1.Ich habe alle verwanten Klassen von Fuzzyset in eine headerdatei und auch in einer .cpp untergebracht.
2.Ich habe den Vektor nicht im Destruktor wieder gelöscht. Kann es daran liegen?

error C2065: 'Fuzzyset': nichtdeklarierter Bezeichner

In welcher File, welche line?
Du vergisst anscheinend einfach Punkt 2. von oben.

Messreihe braucht aber den Fuzzysetheader nicht, weil in der Messreihe nur Pointer auf Fuzzyset vorkommen, da reicht eine Forward-Deklaration. Und Fuzzyset braucht wieder die Messreihe gar nicht, weil für ein friend brauchst man (zumindest hier) nicht einmal eine Forward-Deklaration. Sei mit dem Einbinden von Headern sparsam. Binde genau das ein, was du brauchst. Verlass dich aber wiederum nicht darauf, dass andere Header (über die du keine Kontrolle hast) indirekt etwas einbinden, was du brauchst.

Ein paar Sachen zu deinem Code:
- globale Variablen
- Ein Klassenmember mit init im Namen klingt so, als sollte er ein Konstruktor sein
- Du hast riesige Speicherlöcher, da du dich selber in dynamischer Speicherverwaltung versuchst, aber keine Ahnung von den Grundlagen hast. Es sieht so aus, als sollte dein vector gar keine Pointer auf ein Fuzzyfeld enthalten, sondern konkrete Fuzzytrapezobjekte.
- Soll die Messreihe wirklich ein friend vom Fuzzyfeld sein? friend ist die starkste Bindung zwischen Klassen die C++ kennt. Viele Anfänger halten es für ein Mittel um Schreibarbeit und/oder sauberes Design einzusparen. So ist das definitiv nicht gedacht.
- Fuzzyset braucht auf jeden Fall einen virtuellen Destruktor, da du anscheinend vor hast, Polymorphie zu betreiben.

Der dritte und der fünfte Punkt sind ganz schwerwiegende Fehler. Die anderen Punkte sind sehr schlechte Designentscheidungen, die zwar technisch gesehen (noch) funktionieren, dir das Leben aber noch sehr schwer machen werden.

1. Achte darauf, dass du alles richtig inkludierst (inkludierst du z. B. die Headerdatei zu Fuzzy Trapez?)

ich habe jeweils in der Headerdatei die .h der anderen Klassen inkludiert. Das müsste doch dann passen, oder (und natürlich die Klasse.h in der jeweilige Klasse.cpp)?

2. Deklaration in den Header, Definition in die Source. Nich' vergessen,

error C2065: 'Fuzzyset': nichtdeklarierter Bezeichner

In welcher File, welche line?

bei der Deklaration des Vektors in der Headerdatei

Du vergisst anscheinend einfach Punkt 2. von oben.

[/quote]da habe ich eigentlich penibel drauf geauchtet... [quote]

da habe ich eigentlich penibel drauf geauchtet...

Oh nein, ich meinte Punkt 1. Ich denke du hast vergessen, den Header von deiner Klasse zu inkludieren.

Du hast eine zirkulare Abhängigkeit zwischen deinen beiden Headern. Ein include ist nur eine dumme Textersetzung, am Ende steht einer von beiden Headern vorne und der andere wird nicht mehr davor eingesetzt, wegen dem pragma once (aber mach das nicht weg! das wäre nicht die Lösung).

Messreihe braucht aber den Fuzzysetheader nicht, weil in der Messreihe nur Pointer auf Fuzzyset vorkommen, da reicht eine Forward-Deklaration. Und Fuzzyset braucht wieder die Messreihe gar nicht, weil für ein friend brauchst man (zumindest hier) nicht einmal eine Forward-Deklaration. Sei mit dem Einbinden von Headern sparsam. Binde genau das ein, was du brauchst. Verlass dich aber wiederum nicht darauf, dass andere Header (über die du keine Kontrolle hast) indirekt etwas einbinden, was du brauchst.

Könntest du mir vielleicht mal kurz zeigen, wie so eine Forward Deklaration in meinem Fall aussehen würde? Ich steh mit meinen Programmierkenntnissen leider noch ziemlich am Anfang...

SeppJ schrieb:

Du hast eine zirkulare Abhängigkeit zwischen deinen beiden Headern. Ein include ist nur eine dumme Textersetzung, am Ende steht einer von beiden Headern vorne und der andere wird nicht mehr davor eingesetzt, wegen dem pragma once (aber mach das nicht weg! das wäre nicht die Lösung).

Messreihe braucht aber den Fuzzysetheader nicht, weil in der Messreihe nur Pointer auf Fuzzyset vorkommen, da reicht eine Forward-Deklaration. Und Fuzzyset braucht wieder die Messreihe gar nicht, weil für ein friend brauchst man (zumindest hier) nicht einmal eine Forward-Deklaration. Sei mit dem Einbinden von Headern sparsam. Binde genau das ein, was du brauchst. Verlass dich aber wiederum nicht darauf, dass andere Header (über die du keine Kontrolle hast) indirekt etwas einbinden, was du brauchst.

Könntest du mir vielleicht mal kurz zeigen, wie so eine Forward Deklaration in meinem Fall aussehen würde? Ich steh mit meinen Programmierkenntnissen leider noch ziemlich am Anfang...

Eine Vorwärtsdeklaration braucht man bei zyklischen Abhängigkeiten von Objekten oder Funktionen. Beispiel:

class A; // Vorwärtsdeklaration

Damit existiert eine Klasse A. Von der weiss aber keiner die Größe oder deren Elemente, also können im Moment nur Zeiger oder Referenzen dessen Typs erstellt werden (sonst spuckt der Compiler was aus).

void func(int); //Auch eine Vorwärtsdeklaration

Am schlauesten ist das folgende Konstrukt:

Vorwärtsdeklaration A
Vorwärtsdeklaration B

Definition der Klasse A//Zu diesem Zeitpunkt können Funktionen als Parameter Referenzen und Pointer auf die beiden Klassen nehmen 
Definition der Klasse B

Implementierung aller Methoden von A //Zu diesem Zeitpunkt können alle Funktionen beider Klassen verwendet werden (egal von wo).  Es können jetzt auch Instanzen beider Klassen erstellt werden
Implementierung aller Methoden von B

Könntest du mir vielleicht mal kurz zeigen, wie so eine Forward Deklaration in meinem Fall aussehen würde? Ich steh mit meinen Programmierkenntnissen leider noch ziemlich am Anfang...

Ich zeige dir jetzt den ultimativen Geheimtipp der Computerbedienung, der Programmierung und des Lebens allgemein:
Google: Forward-Deklaration

class MessreiheFFT
{
...
     void methodeB();
     void initFuzzyfeld();
     std::vector <Fuzzyset**> fuzzyfeld;
}
;
void MessreiheFFT::initFuzzyfeld()
{
	for (int i=0;i<anzmessdaten;i++)
	{
		Fuzzyset* hilf[2];
		hilf[0] = new FuzzyTrapez;
		hilf[1] = new FuzzyTrapez;
		fuzzyfeld.push_back(hilf);
	}

}

Wenn ich jetzt allerdings von einer anderen Methode darauf zugreifen möchte, ist der Vektor wieder leer.

Zeig mal die Methode, die dann auf den vector zugreift.

Fuzzyset* hilf[2];
		hilf[0] = new FuzzyTrapez;
		hilf[1] = new FuzzyTrapez;
		fuzzyfeld.push_back(hilf);

Preisfrage: Wann wird das Array hilf zerstört? Was genau wird in dem Vektor gespeichert?

Wenn du das nicht beantworten kannst, befinden sich deutlich zuviele Sternchen in deinem Quellcode.

Ich glaube du hast da was nicht verstanden. Du sollst nicht selbst dynamisch Speicher allokieren. Wenn wir dir sagen, benutze STL-Container die das professionel implementiert für dich erledigen, dann sollst du sie ausschließlich verwenden, d. h. nicht einen vector mit Zeigern auf andere C-Style Arrays.