Eigene Klasse in Form deklarieren .. geht nicht

Alexander Kempf

Zeig doch mal mehr von Deiner Header-Datei.

maYer

Form Interface

#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();
};

PuppetMaster2k

Hast du das #endif nur vergesen zu kopieren oder fehlt das tatsächlich?

Alexander Kempf

Mach doch mal eine Forward-Deklaration der Klasse user in Interface.h. Vielleicht hast Du irgendwelche gegenseitigen includes.

Gruß,

Alexander

Jansen

Wenn das fehlen würde hätte der Compiler sich schon beschwert.

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.

maYer

Hmm includereinfolge "könnte" es sein. was ist ein Forward include ? gibt es bestimmte compilerderiktiven die ich verwenden kann ?

danke

Alexander Kempf

Probier's doch mal mit einer Forward-Deklaration:

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

maYer

Alles klar, aber was soll das bringen ( Prgrammiertechnisch ).
Das die Klasse im Namespace vorhanden ist ?

nur zur info...

Alexander Kempf

maYer schrieb:

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

maYer

Also alex dein Trick hilft wirklich.
Man kann das class aber auch vor die deklaration selber setzten.

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

Alexander Kempf

maYer schrieb:

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

maYer

Doch ich denke ich kann dir folgen.
Du brauchst dich nicht wundern warum er nciht bis dahin vorgedrungen ist, das sit ein recht großes projekt, mit beinahe 45 include files.

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