die eine Klasse ist ein Klasse abgeleitet von TSTringGRid die andere ist keine VCL klasse.

Wenn ich nun unter

void __fastcall Button14Click(TObject *Sender);
	void __fastcall Button15Click(TObject *Sender);
	void __fastcall Button16Click(TObject *Sender);
private:	// Anwender-Deklarationen

public:		// Anwender-Deklarationen
    user *myuser; <-
	__fastcall TInterface(TComponent* Owner);
    dbcontainer *ap_container;

bringt er mir einen error, das user *myuser eine ungültige Deklaration ist.
Die user.h ist oben inlcuded un funktionier auch in der cpp, aber nicht im Header.

Woran kann das liegen ?

Gruß,

Alexander

#include <Classes.hpp>

Classenname kann nicht der Grund sein, habe schon andere probiert.

Wäre echt dankbar für die Lösung, danke an alle

#ifndef InterfaceH
#define InterfaceH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ComCtrls.hpp>
#include <Tabnotbk.hpp>

#include "dbcontainer.h"
#include "DBGridDataConverter.h"

#include "projects.h"
#include <Menus.hpp>
#include "user.h"

//---------------------------------------------------------------------------
class TInterface : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
	TGroupBox *GroupBox1;
	TButton *Button1;
	TButton *Button2;
	TButton *Button3;
	TButton *Button4;
	TPageControl *projects_sheet;
	TTabSheet *new_projects_frame;
	TTabSheet *act_projects_frame;
	TTabSheet *my_projects_frame;
	TTabSheet *search_projects_frame;
	TPopupMenu *all_projects_pm;
	TMenuItem *Details1;
	TGroupBox *project_details;
	TEdit *ap_title;
	TLabel *Label1;
	TEdit *ap_status;
	TLabel *Status;
	TLabel *ap_date;
	TMemo *ap_descr;
	TMemo *ap_addings;
	TLabel *Label2;
	TGroupBox *ap_gb_container;
	TButton *ap_back;
	TButton *sort_puid_pos;
	TButton *sort_puid_neg;
	TButton *Button7;
	TButton *Button8;
	TButton *Button9;
	TButton *Button11;
	TButton *Button12;
	TButton *Button13;
	TButton *Button14;
	TButton *Button15;
	TButton *Button16;
	TButton *Button5;
	void __fastcall act_projects_frameShow(TObject *Sender);
	void __fastcall Details1Click(TObject *Sender);
	void __fastcall ap_backClick(TObject *Sender);
	void __fastcall sort_puid_posClick(TObject *Sender);
	void __fastcall sort_puid_negClick(TObject *Sender);
	void __fastcall Button8Click(TObject *Sender);
	void __fastcall Button7Click(TObject *Sender);
	void __fastcall Button9Click(TObject *Sender);
	void __fastcall Button5Click(TObject *Sender);
	void __fastcall Button11Click(TObject *Sender);
	void __fastcall Button12Click(TObject *Sender);
	void __fastcall Button13Click(TObject *Sender);
	void __fastcall Button14Click(TObject *Sender);
	void __fastcall Button15Click(TObject *Sender);
	void __fastcall Button16Click(TObject *Sender);
private:	// Anwender-Deklarationen

public:		// Anwender-Deklarationen

	__fastcall TInterface(TComponent* Owner);

    dbcontainer *ap_container;
    user *myuser;

    void show_all_parojects();
    void show_projects_details(AnsiString pid);
    AnsiString action;
    AnsiString cur_pid;
    AnsiString sort_by;
    AnsiString sort_method;

};

an der stell user *myuser;
gibt es folgenden debugger error :

[C++ Fehler] Interface.h(81): E2303 Typname erwartet
[C++ Fehler] Interface.h(81): E2139 In Deklaration fehlt ;

Header user.h:
[code]
#ifndef userH
#define userH
#include <Classes.hpp>
#include "db_handle.h"
#include "login.h"
//---------------------------------------------------------------------------

class user
{
protected:
AnsiString user_id;
AnsiString user_name;
AnsiString user_pw;
AnsiString user_group;
public:
user(){};
bool user_login();
bool logged_in();
AnsiString get_user_group();
AnsiString get_user_id();
};

Gruß,

Alexander

Ansonsten: das Problem ist nicht nachvollziehbar, prinzipiell sieht alles richtig aus.
Ggf. solltest du mal die include-Reihenfolge variieren, also die user.h weiter nach oben stellen.

danke

maYer schrieb:

Form Interface

#ifndef InterfaceH
#define InterfaceH
//---------------------------------------------------------------------------
//...jede Menge includes
#include "user.h"

// Forward-Deklaration
class user;
//---------------------------------------------------------------------------
class TInterface : public TForm
{
  // alles wie gehabt
};

Gruß,

Alexander

nur zur info...

Alles klar, aber was soll das bringen ( Prgrammiertechnisch ).

Soweit ich das verstehe, teilst Du damit dem Compiler mit: "Diese Klasse gibt es und Du hast das zu schlucken."
Wenn Du die Klasse dann irgendwo verwendest, muss sie aber dann wirklich vorhanden sein. Im Klartext:
Es ist OK eine Forward-Deklaration im Header zu machen, solange Du in der zugehörigen *.cpp einen include
auf die Header-Datei hast, in der die Klasse tatsächlich definiert (oder deklariert?) wird.
Wenn Du gegenseitige includes hast, dann sorgt das #ifndef dafür, dass in ungünstigen Konstellationen die
Klassendefinition "ausgeblendet" wird. Das sieht dann für den Compiler so aus, als existiere die Klasse gar nicht.

Hast Du's eigentlich mal ausprobiert?

Gruß,

Alexander

class user *myuser;

Das wäre geschafft.
Nur hab ich nicht verstanden, warum das ganze bzw. was es zu bedeuten hat und das ist mir fast wichtig.

wieso muss ich user explizit als class definieren, wenn sie doch schon so deklariert wurde ? ( würde gerne wissen, ob die beiden Verben nun gepasst haben [deklarieren /Definieren])

Wäre super wenn das jemand enschlüsseln könnte, in den Büchern hab ich nichts darüber gefunden.

danke

wieso muss ich user explizit als class definieren, wenn sie doch schon so deklariert wurde ?

Wie schon erwähnt liegt das an dem #ifndef.
Ich stelle mir das so vor: Der Compiler kommt auf seinem Weg bei Deiner user.h an, um sie zu kompilieren. Dabei wird
dann UserH definiert und er findet ein include von Deiner Interface.h (vielleicht auch in einem anderen Header, der
an der Stelle eingebunden wird). Also versucht der Compiler jetzt erstmal die Interface.h zu kompilieren. In der
Interface.h ist aber ein include von user.h. Also schaut er wieder in user.h. Da UserH jetzt aber definiert ist,
bricht der Compiler hier ab (bzw. findet quasi "nichts", weil durch ifndef ausgeblendet). Bemerkenswert dabei ist,
dass der Compiler bisher noch nicht zu Deiner Klasse user vorgedrungen ist. Beim weiteren Kompilieren von Interface.h
kennt er deshalb user nicht und bricht mit einem Fehler ab.
Durch die Forward-Deklaration teilst Du dem Compiler mit, dass user eine Klasse ist, was dem Compiler an der Stelle
genügt, da ja nur eine Variable deklariert wird, aber keine Methode der Klasse aufgerufen wird. Die Klasse wird
im Header ja gar nicht "verwendet"; das passiert erst in der *.cpp. Dort muss dann auf jeden Fall ein include der
user.h enthalten sein, sonst gibt es einen Fehler in der Art "tritratrulala() ist keine Methode von user, weil der Typ
nicht definiert ist".
Anders sieht die Sache aus, wenn Du einen Header hast, in dem eine Klasse definiert wird, die von user erbt. Dann
begnügt sich der Compiler nicht mit einer Forward-Deklaration. Ist ja auch klar, denn er muß ja die geerbten Methoden
und Klassenvariablen kennen, um einen "Bauplan" für die erbende Klasse erstellen zu können.

Ich hoffe, das ist so einigermaßen richtig und konnte etwas zum Verständis beitragen.

Gruß,

Alexander

Danke dir für die Zeit, die du dir genommen hast