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?

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.

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.

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

Grüße Joe_M.

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?

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

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

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