- #include <ctime>
- t = time() + 12*60
- usleep oder sleep oder Sleep des jeweiligen betriebssystems fuer eine bruchsekunde
- printf ("%d sekunden", t-time());

#include <cstdio>
#include <ctime>
#include <cmath>

#ifdef __WIN32__
#include <windows.h>
#define usleep(n) Sleep((n)/1000)
#else
#include <unistd.h>
#endif

double mytime()
{
    return (double) clock() / CLOCKS_PER_SEC;
}

int main()
{
    getchar();
    double t = mytime() + 12 * 60, x;

    do
    {
        x = t - mytime();
        printf("%02dm %04.1fs\r", (int) (x / 60), fmod(x, 60));
        usleep(50000);
    } while (x >= 0);

    puts("Zeit abgelaufen!");

    return 0;
}

Da kommt ein Fehler, dass <unistd.h> nicht geöffnet werden kann!

Das "oder" ist exklusiv gemeint. D.h. entweder du inklduierst <windows.h> oder <unistd.h>. Nicht beides. <windows.h> macht sinn, wenn du unter Windows arbeitest. <unistd.h>, wenn du unter einem Posix-OS wie z.B. Linux arbeitest.

werner@linux:~> cd /home/werner/code
werner@linux:~/code> g++ countdown.cpp -o countdown.exe
countdown.cpp: In function int main()': countdown.cpp:16: error:Sleep' undeclared (first use this function)
countdown.cpp:16: error: (Each undeclared identifier is reported only once for
each function it appears in.)
werner@linux:~/code>

`sleep´ wird nicht erkannt. So sieht mein dode aus:

#include <iostream>
#include <ctime>

#define usleep(n) Sleep((n)/1000)
#include <unistd.h>

using namespace std;

int main()
{
    cin.get();
    unsigned long t = time(0) + 12*60, x;
    do {
        x = t - time(0);
        cout << "\r" << (x/60) << ":" << (x%60);
        usleep(100000);
    } while (x >= 0);
    cout << "Zeit abgelaufen!";
    return 0;
}

ich habs idiotensicher gemacht.
einfach kompilieren und ausfuehren.

Offensichtlich nicht

Wenn ich dir eines sagen kann dann, dass es immer einen Idioten geben wird der auch das "idiotensicherste" fehlschlagen lässt.

... probier es nochmal mit dem quelltext, der jetzt in dem post steht.

dankeschön, es funktionier

ich HABE den quelltext so geaendert, dass du nicht mehr dein hirn bemuehen musst.

erstmal sollte villeicht geklärt werden, ob ich ein´s habe.

... probier es nochmal mit dem quelltext, der jetzt in dem post steht.

dankeschön, es funktionier

ich HABE den quelltext so geaendert, dass du nicht mehr dein hirn bemuehen musst.

erstmal sollte villeicht geklärt werden, ob ich ein´s habe.

jo das sollte wirklich geklärt werden

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

#include <vcl.h>
#pragma hdrstop

#include "Unit2.h"
#include "Unit1.h"
#include <iostream>
#include <ctime>

#include <windows.h>
#define usleep(n) Sleep((n)/1000)
#pragma package(smart_init)
//---------------------------------------------------------------------------

//   Wichtig: Methoden und Eigenschaften von Objekten der VCL können nur
//   in Methoden verwendet werden, die Synchronize aufrufen, z.B.:
//
//      Synchronize(UpdateCaption);
//
//   wobei UpdateCaption so aussehen könnte:
//
//      void __fastcall timer::UpdateCaption()
//      {
//        Form1->Caption = "In Thread aktualisiert";
//      }
//---------------------------------------------------------------------------

__fastcall timer::timer(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall timer::Execute()
{
        //---- Hier den Thread-Code plazieren----
        String Text;
            unsigned long t = time(0) + 12*60, x;
    do {
        x = t - time(0);
        //cout << "\r" << (x/60) << ":" << (x%60);
        Text =  IntToStr(x/65) + ":" + IntToStr(x%60);
        Form1->Edit1->Text= Text;
        //Form1->Edit1->Refresh();
        usleep(100000);
    } while (x >= 0);
}
//---------------------------------------------------------------------------

Code des Threads.h

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

#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
//---------------------------------------------------------------------------
class timer : public TThread
{            
private:
protected:
        void __fastcall Execute();
public:
        __fastcall timer(bool CreateSuspended);
};
//---------------------------------------------------------------------------
#endif

Code des Formulars:

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
timer *SecondProcess = new timer(true);
  SecondProcess->Priority = tpLower; // niedrigere Priorität setzen
  SecondProcess->Resume(); // Thread jetzt ausführen
}
//---------------------------------------------------------------------------

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

#include <vcl.h>
#pragma hdrstop

#include "Unit2.h"
#include "Unit1.h"
#include <iostream>
#include <ctime>

#include <windows.h>
#define usleep(n) Sleep((n)/1000)
#pragma package(smart_init)
//---------------------------------------------------------------------------

//   Wichtig: Methoden und Eigenschaften von Objekten der VCL können nur
//   in Methoden verwendet werden, die Synchronize aufrufen, z.B.:
//
//      Synchronize(UpdateCaption);
//
//   wobei UpdateCaption so aussehen könnte:
//
//      void __fastcall timer::UpdateCaption()
//      {
//        Form1->Caption = "In Thread aktualisiert";
//      }
//---------------------------------------------------------------------------

__fastcall timer::timer(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall timer::Execute()
{
        //---- Hier den Thread-Code plazieren----
        String Text;
            unsigned long t = time(0) + 12*60, x;
    do {
        x = t - time(0);
        //cout << "\r" << (x/60) << ":" << (x%60);
        Text =  IntToStr(x/[b]60[/b]) + ":" + IntToStr(x%60);
        Form1->Edit1->Text= Text;
        //Form1->Edit1->Refresh();
        usleep(100000);
    } while (x >= 0);
}
//---------------------------------------------------------------------------

ich wuerde mich freuen, wenn du meinen aktuellen code benutzen wuerdest. dann haettest du auch bruchsekunden und eine wesentlich genauere zeitmessung.

65 macht hier keinen Sinn
Kzrt

String Text;
            unsigned long t = time(0) + 12*60, x;
    do {
        if (laeuft == true)
        {
        x = t - time(0);
        //cout << "\r" << (x/60) << ":" << (x%60);
        Text =  IntToStr(x/60) + ":" + IntToStr(x%60);
        Form1->Edit1->Text= Text;
        //Form1->Edit1->Refresh();
        usleep(100000);
        }
    } while (x >= 0);

if (laeuft == true)
 {
   laeuft = false;
   speicher = t;
   Form1->Button2->Caption = "Weiter";
 }
 else
 {
   laeuft = true;
   t = speicher;
   Form1->Button2->Caption = "Pause";
 }

Funktioniert aber nicht. Die Zeit hält zwar an bei der Anzeige jedoch wenn ich auf weiter drücke kommt die Zeit als hätte ich überhaupt nicht auf Pause gedrückt. Woran kann das jetzt liegen

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

#include <vcl.h>
#pragma hdrstop

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

#include <iostream>
#include <ctime>

#include <windows.h>
#define usleep(n) Sleep((n)/1000)
#pragma package(smart_init)

unsigned long t, speicher;
bool laeuft;
TForm1 *Form1;

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

//   Wichtig: Methoden und Eigenschaften von Objekten der VCL können nur
//   in Methoden verwendet werden, die Synchronize aufrufen, z.B.:
//
//      Synchronize(UpdateCaption);
//
//   wobei UpdateCaption so aussehen könnte:
//
//      void __fastcall timer::UpdateCaption()
//      {
//        Form1->Caption = "In Thread aktualisiert";
//      }
//---------------------------------------------------------------------------

__fastcall timer::timer(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall timer::Execute()
{
        //---- Hier den Thread-Code plazieren----
        String Text;
        unsigned long x, y;
        t = time(0) + 1*60;
    do {
        if (laeuft == true)
        {
        x = t - time(0);
        //cout << "\r" << (x/60) << ":" << (x%60);
        Text =  IntToStr(x/60) + ":" + IntToStr(x%60);
        Form1->Edit1->Text= Text;
        //Form1->Edit1->Refresh();
        usleep(100000);
        }
    } while (x >= 0);
    //---- Hier den Thread-Code plazieren----

}

timer *SecondProcess = new timer(true);
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
  SecondProcess->Priority = tpLower; // niedrigere Priorität setzen
  SecondProcess->Resume(); // Thread jetzt ausführen
  laeuft = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 if (laeuft == true)
 {
   laeuft = false;
   speicher = t;
   Form1->Button2->Caption = "Weiter";
 }
 else
 {
   laeuft = true;
   t = speicher;
   Form1->Button2->Caption = "Pause";
 }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)
{
   SecondProcess->Terminate();
}
//---------------------------------------------------------------------------

void __fastcall timer::Execute()
{
    String Text;
    unsigned long x, y;
    t = time(0) + 1*60;
    do {
        if (laeuft == true) {
            x = t - time(0);
            Text =  IntToStr(x/60) + ":" + IntToStr(x%60);
            Form1->Edit1->Text= Text;
        }
        usleep(100000); // muss raus aus dem if sonst haben wir hohe last
    } while (x >= 0);
    //---- Hier den Thread-Code plazieren----

}

//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 if (laeuft == true)
 {
   laeuft = false;
   speicher = t - x;
   Form1->Button2->Caption = "Weiter";
 }
 else
 {
   laeuft = true;
   t = speicher;
   Form1->Button2->Caption = "Pause";
 }
}

Keine Garantie. Kanns nicht ausprobieren mein compiler versteht so komische sachen wie __fastcall und TObject nicht
Kurt

Nimm doch einfach TTimer (wie schon mal gesagt), mit einem Intervall von 1000ms kannst du nen einfachen Countdown machen, den du auch mit der Eigenschaft Enabled unterbechen kannst.

bis bald
akari