while schleife frage

Braunstein

Du könntest deinen rechne()-Prozess auch in einen Thread auslagern. Siehe dazu Hilfe zu TThread.

Havoc

hmm, ja, das hab ich auch schon aufgeschnappt, allerdings hab ich von threads leider gar keine ahnung, und die borland hilfe versteh ich dazu leider nicht wirklich... die meintest du doch oder?

kann mir das vielleicht jemand konkret auf mein problem bezogen sagen wie das geht?

Gerade zu Threads ist die Hilfe sehr ausführlich

Über Datei -> Neu-> Weitere eine Thread Unit mit in das Projekt aufnehmen. Den Code den der Thread erledigen soll im OnExecute reinsetzen.

Dabei folgende Struktur nutzen:

try
	{
	while(!Terminated)
	{
	//hier dein Code
         }
	catch(...)
	{

          .......
	}

Thread starten und stoppen steht in der Hilfe zu TThread

Braunstein

Vielleicht hilft das ja
http://bcb-tutorial.c-plusplus.net/Thread/index.html
http://fatman98.fa.funpic.de/builder_threads.php

Editiert

D:\Programm...

kann nicht helfen

Braunstein

Jetzt Ok?

Havoc

ich werds gleich mal ausprobieren

Havoc

So, ich hab das jetzt mal ausprobiert, und es funktioniert nicht.

fragen:

1. muss ich irgendwo einstellen, dass ich threads überhaupt nutzen kann, bei projekt->optionen vielleicht, ich dachte ich hab das irgendwo mal gelesen

2. er startet mir meinen thread nicht, beziehungsweise ich kann gar nicht kompilieren. ich hab zum starten folgenden code:

void __fastcall TSonnenSystem::Berechnungstarten1Click(TObject *Sender)
{
 new TMyThread(false);
}

und zum beenden:

void __fastcall TSonnenSystem::StopIt1Click(TObject *Sender)
{
   TMyThread->Terminate();
}

Beide male sagt er mir, ein ; fehlt, Typname erwartet, und beim zweiten auch undefiniertes Symbol TMyThread (mein Thread heißt schon so )

3. kann ich aus dem thread heraus eine funktion aus meiner unit1 aufrufen?
ich hab mir das so gedacht:

void __fastcall TMyThread::Execute()
{
   while (!Terminated) TSonnenSystem->rechne();
}

4. ich hab außerdem noch außer meiner unit1 und jetzt durch den thread unit2 eine weitere name.cpp mit folgendem code, könnte das ein problem sein?

#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
USEFORM("Unit1.cpp", SonnenSystem);
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
        try
        {
                 Application->Initialize();
                 Application->Title = "Titel";
                 Application->CreateForm(__classid(TSonnenSystem), &SonnenSystem);
                 Application->Run();
        }
        catch (Exception &exception)
        {
                 Application->ShowException(&exception);
        }
        catch (...)
        {
                 try
                 {
                         throw Exception("");
                 }
                 catch (Exception &exception)
                 {
                         Application->ShowException(&exception);
                 }
        }
        return 0;
}

lädt der mir hier meinen thread wohl gar nicht? was müsste ich denn reinschreiben, dass ers tut? oder muss ich den bei meiner unit1 irgendwo initialisieren?

hmm, das wars erstmal, danke schonmal an alle!

Dasd

Hättest nach dem 3. mal Bearbeiten ruhig auch die Code-Tags verwenden können.

1.) Du solltest schon eine komplette Instanz deines Threads erstellen und die einem Zeiger zuweisen. Dann kannst du über den auch Terminate() aufrufen.

2.) TSonnenSystem ist doch der Name der Klasse und nicht der Instanz, oder?

Havoc

TSonnenSystem ist wohl das, was standardmäßig TForm1 ist.

wie geht denn das mit der instanz und dem zeiger? sorry, aber blick leider echt nicht durch...

Braunstein

Hallo,

Eine Instanz von TMyThread erzeugt man so

TMyThread *mythread = new TMyThread(false);

Vielleicht solltest du dir noch ein paar Grundlagen zu Typen, Zeigern sowie Klassen durchlesen. Oben auf der Forumseite ist ein Link zu entsprechenden Tutorials.

Havoc

danke!
ja, werd ich machen

jetzt aber doch noch kurz: wo kommt die instanz hin? der meckert bei mir immer.

Braunstein

1. Wenn dein Compiler meckert, sag uns auch was (Fehlermeldung)
2. Die Instanz von TMyThread könnte z.Bsp. eine Membervariable deiner Form sein, oder global

Havoc

global würde also heißen in eine der headerdateien, aber in welche und wo da?
in unit1 (ursprüngliche) oder unit2 (thread)? wenn ich nämlich in die unit2.h unter public reinschreib, schluckt er das zwar, sagt mir aber immer noch "undefiniertes Symbol" beim aufruf von TMyThread->Resume();

Braunstein

Wie schon gesagt, du solltest dir erst einmal die Grundlagen aneignen.

TMyThread->Resume();

kann ja nicht funktionieren, da TMyThread ein Typ und keine Instanz ist. Wenn eine Variable mythread vom Typ TMyThread public member von TForm1 wäre würde der Aufruf z.Bsp. so aussehen

Form1->mythread->Resume();

Das sind aber, wie schon betont, absolute C++ Grundlagen.

Havoc

du hast leider vollkommen recht, das mir die grundlagen fehlen, ich hab mir mal das tutorial von der uni marburg wars glaub ich runtergeladen, aber das durchzuarbeiten dauert wohl seine zeit, und die fehlt ir im moment leider, weswegen ich euch nerve.
auf lange sicht will ich mir diese auf alle fälle aneignen, ich bin nur leider fälschlicherweise davon ausgegangen, dass es leicht wäre mein konkretes problem zu lösen, threads scheinen aber wohl zwangsläufig was etwas tiefergehendes zu sein.

in anbetracht dessen versuche ich jetzt mal den mittelweg zu gehen und das mit den threads ohne vorherige erarbeitung der grundlagen an dem einfachen beispiel, das hier beschrieben ist:
http://bcb-tutorial.c-plusplus.net/Thread/artikel5.html
zu verstehen. mach ich einfach alles so wie es da steht, hab ich genau das gleiche problem wie bei meinem programm vorher. also setze ich

TMyThread *mythread = new TMyThread(false);

in die headerdatei meiner unit2, die des threads. (logischer würde mir ja erscheinen, es in unit1.h zu schreiben, aber da bringt er folgende fehler:

[C++ Fehler] Unit1.h(22): E2303 Typname erwartet
[C++ Fehler] Unit1.h(22): E2139 In Deklaration fehlt ;
[C++ Fehler] Unit1.cpp(34): E2288 Zeiger auf Struktur auf linker Seite von -> oder von ->* erforderlich*

)

so, und jetzt merke ich grad dass es mir unsinnig erscheint, einen thread, dessen instanz in TMyThread steht mit Form1->(...) aufzurufen, da er dort ja nicht zu finden ist... also, ist jetzt schon alles falsch?

danke für die geduld!

-**xXx**-

Hast du denn die unit2 in der unit1 includiert?
Sonst is der Thread da ja auch gar nicht bekannt...

mfg
xXx

Braunstein

Das hier
TMyThread *mythread = new TMyThread(false);
hat im Header nichts zu suchen.
In Unit1.h unter public kommt sowas

TMyThread *mythread;

In diese Header musst du natürlich den Header wo TMyThread deklariert worden ist inkludieren (oder eine Forwarddeklaration machen).
Wenn du den Thread nun verwenden willst mußt du ihn dann noch mit new erzeugen.

Form1->mythread = new TMyThread(false);

dann läuft er auch los.
Alternativ dazu kannst du den Thread auch im Konstruktor von Form1 so erzeugen

Form1->mythread = new TMyThread(true);

und dann bei Bedarf mit Resume starten.

Havoc

So, hier mal eine deutlich bessere, denk ich, version, die aber immer noch nicht funktioniert... fragen stehen als kommentare im code.

unit1.h:

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <Menus.hpp>
#include <ActnList.hpp>
#include <csignal>

class TSonnenSystem : public TForm

__published: 
		(...)

private: 
		(...)
		TThread *mythread;   	//ob das richtig oder nicht ist, bin ich mir nicht sicher, aber bevor ich das hatte hat er mir bei 
					// Berechnungstarten1Click immer "undefiniertes Symbol mythread" gebracht. TMythread *mythread, wie   					
					//ichs nach lesen einiger Tutorials vermutet hätte, ging hier nicht, folgende Fehler:
					//	[C++ Fehler] Unit1.h(155): E2303 Typname erwartet
					//	[C++ Fehler] Unit1.h(155): E2139 In Deklaration fehlt ;

public:	
        __fastcall TSonnenSystem(TComponent* Owner);

};
//---------------------------------------------------------------------------
extern PACKAGE TSonnenSystem *SonnenSystem;

//---------------------------------------------------------------------------
#endif

unit1.cpp:

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
#pragma package(smart_init)
#pragma resource "*.dfm"

#include "fstream.h"
#include "math.h"

TSonnenSystem *SonnenSystem;
__fastcall TSonnenSystem::TSonnenSystem(TComponent* Owner) : TForm(Owner)
{
 TMyThread *mythread = new TMyThread(true);
 mythread->Priority=tpIdle;
 mythread->SetSonnenSystem(SonnenSystem);	//SetSonnenSystem ist eine Methode in TMyThread
}

void TSonnenSystem::rechne()
{
	(...)
}

void __fastcall TSonnenSystem::Berechnungstarten1Click(TObject *Sender)
{
    if (mythread->Suspended)
     {
       mythread->Resume();  // starten...
     }
    else
     {
       mythread->Suspend(); // ...oder anhalten
     }
}

unit2.h:

//---------------------------------------------------------------------------

#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include "Unit1.h"
//---------------------------------------------------------------------------
class TMyThread : public TThread
{
private:

        TSonnenSystem *Sonne;

protected:
        void __fastcall Execute();
        void __fastcall GuiElements();		//brauch ich glaub ich gar nicht, oder?
public:
        __fastcall TMyThread(bool CreateSuspended);
        SetSonnenSystem(TSonnenSystem *SonnenSystem);
};

//---------------------------------------------------------------------------
#endif

unit2.cpp:

#include <vcl.h>
#pragma hdrstop

#include "Unit2.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------

__fastcall TMyThread::TMyThread(bool CreateSuspended)
        : TThread(CreateSuspended)
{
    FreeOnTerminate = true;
}

void __fastcall TMyThread::Execute()
{
     while (!Terminated)		
     {Sonne->rechne();			//So, und hier bringt er nun folgende Fehler:
					//	[C++ Fehler] Unit2.cpp(31): E2247 Zugriff auf 'TSonnenSystem::rechne()' nicht m?lich
					//	[C++ Fehler] Unit2.cpp(32): E2188 Ausdruckssyntax
					//	[C++ Warnung] Unit2.cpp(40): W8070 Funktion sollte einen Wert zurckgeben
					//hat aber nichts mit dem Inhalt von rechne() zu tun, da er das gleiche auch bei einer leeren 							
					//Funktion (oder heißt es Modul?) bringt. muss ich da noch einen Zeiger auf rechne setzen und dem
					//Thread irgendwie bergeben? Wenn ja, wie?

      catch(...);			
     }
}

TMyThread::SetSonnenSystem(TSonnenSystem *SonnenSystem)
{
 Sonne=SonnenSystem;
}

Braunstein

Hallo,

Ändere das erstmal wie folgt ab.

unit1.h:

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <Menus.hpp>
#include <ActnList.hpp>
#include <csignal>

class TMyThread;  //Forwarddeklaration um TMyThread bekannt zu machen

class TSonnenSystem : public TForm

__published:
        (...)

private:
        (...)

public:   
        __fastcall TSonnenSystem(TComponent* Owner);
        TMyThread *mythread;       // nach public verschoben und Typ in TMyThraed geändert
};
//---------------------------------------------------------------------------
extern PACKAGE TSonnenSystem *SonnenSystem;

//---------------------------------------------------------------------------
#endif