Klassen Vereerben (auch ein Thread Klasse)

Hallo habe ein Problem mit Klassen.
1.) Ich habe eine Klasse die folgendermaßen deklariert ist:

class Test
{
  public:
    void schreiben();
    void empfangen();
};

2.) Habe ich einen Thread:

class empfangen : public TThread
{            
private:
protected:
        void __fastcall Execute();
public:
        __fastcall empfangen(bool CreateSuspended);
};

3.) Den Thread kann ich folgendermaßen aufrufen:

empfangen *SecondProcess = new empfangen(false);
  SecondProcess->Priority = tpLower; // niedrigere Priorität setzen
SecondProcess->Resume(); // Thread jetzt ausführen

4.) Die erste Klassen rufe ich folgender Maßen auf:

Test Schnittstelle;
Test.schreiben();

Geht es eigentlich, dass ich einer Klasse mehrere Klassen vererb?

Jetzt kommt mein Problem ich möchte über die Klasse test den Thread aufrufen. Hierzu möchte ich, die Thread Klasse vereerben. Aber das funktioniert nicht. Wie kann ich das Problem lösen?

Sunday

Hansmaker84 schrieb:

Geht es eigentlich, dass ich einer Klasse mehrere Klassen vererb?

schonmal ausprobiert?

-> ja? was ist passiert?
-> nein? dann wird es zeit.

wieso willst du test von thread erben lassen? dann sei dir im klaren, das test auch ein thread ist! wenn du den thread nur nutzen willst, deklariere ihn als member der klasse.

Folgendes habe ich ausprobiert:

class Test : public empfangen
{
  public:
    void schreiben();
    void empfangen();
};

Dann bekomme ich folgende Fehlermeldung:
[C++ Fehler] Unit1.cpp(12): E2459 Klassen im VCL-Stil müssen mit dem Operator new erstellt werden

Diesen Fehler habe ich so behoben:

Test* Klasse1 = new Test ;

Jetzt kommt diese Fehlermeldung:
[C++ Fehler] Unit1.cpp(13): E2125 Compiler konnte Standardkonstruktor nicht für die Klasse 'RS232' generieren

Was ist "member der klasse" habe ich noch nicht gehört, kannst du mir das mal erklären.

Sunday

Hansmaker84 schrieb:

E2125 Compiler konnte Standardkonstruktor nicht für die Klasse 'RS232' generieren

in dieser fehlermeldung steht doch schon alles. deiner klasse test fehlt der standard-konstruktor.

class empfangen : public TThread
{            
  protected:

        void __fastcall Execute();

  public:

        __fastcall empfangen(bool CreateSuspended);
}; 

// abgeleitete Klasse
class Test : public empfangen
{
  public:

    void schreiben();
    void empfangen();

    // Standard-Konstruktor
    // -> std.-maessig ist der Thread suspended gestartet
    // -> wenn false dann halt nicht
    Test()                           : empfangen(true)            {}    

    // Konstruktor mit Parameter 
    // -> kannste z.b. verwenden um das Erzeugen des Threads zu steuern
    //    da dieser ja den Parameter erwartet
    Test(const bool CreateSuspended) : empfangen(CreateSuspended) {}
};

p.s. code-tags funzen nicht

@Sunday: Mach mal die Kursiv-Tags um das Wort suspended weg. Dann klappts auch mim Code-Tag.

Grüße Joe_M.

Sunday

seltsam, hab das doch frueher schon kursiv und fett im code benutzt...

Danke,
diese Fehler ist jetzt auch behoben. Jetzt kommt aber schon der nächste Fehler und zwar in dieser Zeile:

Klasse1.schreiben();

Meldung:
[C++ Fehler] Unit1.cpp(26): E2294 Auf linker Seite der Struktur ist . oder .* erforderlich

Diese habe ich behoben indem ich folgendes schrieb:

Klasse1.*schreiben();

Jetzt lautet die Fehlermeldung:
[C++ Fehler] Unit1.cpp(26): E2268 Aufruf der undefinierten Funktion 'schreiben'

Was mache ich jetzt falsch?

wedmer

Klasse1->schreiben();

Sunday

wenn du klassen dynamisch mit new erzeugst, musst du mit -> auf die funktionen und variablen der klasse zugreifen.

Vielendank!
Wo muss ich eigentlich eine Variable deklarienen die ich in beiden Klassen verwenden möchte, aber von außerhalb nicht sichtbar sein soll.

akari

Hallo

Als protected von empfangen, dann kannst du sowohl von empfangen als auch von Test drauf zugreifen. Aber von außerhalb der Klassen nicht.

bis bald
akari

Ich kann zwar von beiden Klassen auf die Variable zugreifen.

Wenn ich aber bei empfangen die Variable auslese ist sie 0, zuvor habe ich Sie bei test auf 5 gesetzt.

void test::schreiben()
{
  i = 5;
  empfangen *SecondProcess = new empfangen(false);
  SecondProcess->Priority = tpLower; // niedrigere Priorität setzen
  SecondProcess->Resume(); // Thread jetzt ausführen
}

Hier ist die Variable aber null:

void __fastcall empfangen::Execute()
{
  i = 2;
}

akari

Hallo

Ich glaube du hast da das Konzept falsch verstanden.
Du willst mit schreiben() eine neue Thread-Instanz von Typ empfangen erzeugen und dieser Instanz noch eine zusätzliche Variable für deren Methode empfangen() (bemerkst du die Doppeldeutigkeit deiner Begriffe?) übergeben? Dann ist das von mir gesagte natürlich nicht ausreichend. Am besten übergibst du den Wert als zusätzlichen Wert des Parameters des Konstruktors von empfangen.
Übrigens scheint es ganz so, als ob die Thread-Instanz die du in empfangen erzeugst, niemals wieder gelöscht wird.

bis bald
akari