C++ - TIME

Dieses Thema C++ - TIME im Forum "Webentwicklung, Hosting & Programmierung" wurde erstellt von Game12, 17. Jan. 2006.

Thema: C++ - TIME In QB gibt es eine Variable TIME , die die Sekunden seit Mitternacht angibt . gibt es etwas änliches in C++. Ich...

  1. In QB gibt es eine Variable TIME , die die Sekunden seit Mitternacht angibt .
    gibt es etwas änliches in C++. Ich brauche das um Warteschleifen zu machen bei denen sich die länge der Wartezeit nicht auf die Geschwindigkeit des Rechners bezieht wie in diesem Beispiel :

    Code:
     long x;
     for(x=0;x<500000000;1 )
     {
       x++;
     }

    edit :


    wie kann man Zahlen Zufällig bestimmen?

    also ich will z.B. das x Zwischen 100 und 1000 liegt und bei (jedem) Programmstart einer anderen Zahl entspricht.

    ich weiß QB nevt euch :

    Code:
    x= INT(RND(1) * 900 +100) 
     
  2. Gibt's nicht unter Standard-C++, da es plattformabhängig ist. D.h., man kann sich schon etwas zusammenbasteln (z.B. mit Hilfe der time-Funktion), aber es ist weder schön noch genau. Du solltest dafür die Funktion Sleep (WinAPI) verwenden. Hat auch noch den Vorteil, dass der Thread dann wirklich inaktiv ist und keine Rechenzeit verbraucht.

    int x= rand() % 901 + 100;

    Dann vorher (einmal)

    srand((unsigned)time(NULL));

    Für srand und rand evtl. cstdlib einbinden, für time ctime. Also
    #include <cstdlib>
    #include <ctime>
     
  3. kann man auch Zehntel- , Hundertstel-, Tausenstellsekunden seit Mitternacht angeben ?


    also so,dass es eine Gleitkommazahl (float,double) sein müsste ?

    ich brauch es für dieses Programm :

    Code:
    // Programm zur Zählgeschwindigkeits Berechnung...
    #include <iostream>
    #include <ctime>
    
    using namespace std;
    int main ()
    {
    
     int c[100000];
     long b=1;
     long a;
     long x;
     long y=0;
     int d;
     int e;
     double f=0;
     int g;
    
    
    
     cout <<  Programm zur Zählgeschwindigkeits Berechnung<< endl;
     cout << endl <<  Wieviele Tests wollen sie durchführen(max. 100000) ? :;
     cin >> a;
     cout <<  Wie Hoch soll der Rechner zählen ?           :;
     cin >> g;
     cout << endl << endl;
    
     if (a <=0 )
     {
      cout << Falsche Eingabe, wird beendet...;
      cin.get();
      cin.get();
      return 1;
     }
     if(g<=0)
     {
      cout<<  Falschge Eingabe, wird beendet...;
      cin.get();
      cin.get();
      return 1;
     }
    
    
    
     for(d=0;d<a;++d)
     {
    
      cout << Test << b <<: ;
      b++;
    
      c[y]= ((unsigned)time(NULL));
    
      for(x=1;x < g;1)
      {
       x++;
      }
      c[y] =((unsigned)time(NULL))-c[y];
      cout << c[y] << Sekunden<< endl;
      ++y;
     }
    
     for(e=0;e<a;++e)
     {
    
      c[e] =
      f+=c[e];
    
     }
    
     f = f / e;
    
     if (a == 1)
     {
      cout << endl << Mittelwert des Tests:  << f;
     }
    
     else if (a > 0)
     {
      cout << endl << Mittelwert der Tests:  << f;
     }
    
     else
     {
     cout << Falsche eingabe...;
     }
    
     cin.get();
     cin.get();
    
     return 1;
    }
    

    edit:

    n QB gibt es den Locate befel ,der Buchsaben an die gewünschte stelle setzt :BSP



    Code:
    LOCATE 4,15 PRINTO


    Code:

    ausgabe :


    O




    wie kann man in C++ z.B die Pfeiltasten,ESC,ENTER usw benutzen , wie kann ich ein spiel screiben ,dass auf die Pfeiltasten reagiert...?
     
  4. Mir ist nicht ganz klar, warum Du die seit Mitternacht vergangene Zeit haben willst (oder eine Warteschleife). Wenn Du eine einfache Warteschleife brauchst, nimm Sleep (Angabe der Zeit in Millisekunden). Wenn Du die Uhrzeit haben willst, time (ANSI) oder Windows-Funktionen. Wenn Du einen Zeitraum genau messen willst, clock (Prozesszeit; ANSI) oder die Windows-Funktion QueryPerformanceCounter.

    Siehe unten. Das funktioniert übrigens nicht wirklich, da die meisten Compiler Deine Schleife (schon standardmäßig) einfach wegoptimieren, wenn Du nicht auf Debug kompilierst (und mit->volatile' stimmt das Ergebnis nicht mehr, da der Code aufgebläht wird).

    Nicht optimiert:
    Code:
    	mov	DWORD PTR _x$63405[ebp], 1
    	jmp	SHORT $L63406
    $L63407:
    	mov	eax, DWORD PTR _x$63405[ebp]
    	add	eax, 1
    	mov	DWORD PTR _x$63405[ebp], eax
    $L63406:
    	mov	eax, DWORD PTR _x$63405[ebp]
    	cmp	eax, DWORD PTR _nLoops$[ebp]
    	jge	SHORT $L63408
    	jmp	SHORT $L63407
    $L63408:
    
    Optimiert:
    Code:
     
    
    ;)

    Du kannst aber count bzw. QueryPerformanceCounter verwenden, wenn Du wissen willst, wie effizient Dein Programm ist und welche Wirkung Änderungen diesbezüglich haben; darum habe ich trotzdem beides unten eingefügt. BTW: Variablennamen können länger als ein Buchstabe sein ;) <duck>

    Code:
    #include <iostream>
    #include <ctime>
    #include <windows.h>
    
    using namespace std;
    
    const long maxTests= 100000;
    
    bool getValues(long& nTests, long& nLoops)
    {
      cout <<  Programm zur Zählgeschwindigkeits-Berechnung << endl;
      cout << endl <<  Wieviele Tests wollen sie durchführen (max.;
      cout << maxTests << )? : ;
      cin >> nTests;
      cout <<  Wie hoch soll der Rechner zählen?                   : ;
      cin >> nLoops;
      cout << endl << endl;
    
      if ((nTests <= 0) || (nTests > maxTests) || (nLoops <= 0))
        return false;
      else
        return true;
    }
    
    void runtest(long nLoops, int pass, double results[])
    {
      clock_t start= clock();
    
      for(long x=1; x<nLoops; ++x);
    
      clock_t finish= clock();
      results[pass]= (double)(finish - start) / CLOCKS_PER_SEC;
    }
    
    void runtest2(long nLoops, int pass, double results[])
    {
      LARGE_INTEGER frequency, start, finish;
    
      SetThreadAffinityMask(GetCurrentThread(), 1);
      QueryPerformanceFrequency(&frequency);
      QueryPerformanceCounter(&start);
    	
      for(long x=1; x<nLoops; ++x);
    
      QueryPerformanceCounter(&finish);	
      results[pass]= (finish.QuadPart - start.QuadPart) / (double)frequency.QuadPart;
    }
    
    double average(long nTests, double results[]) {
      double sum= 0;
      for(long e=0; e<nTests; ++e)
        sum+= results[e];
      return sum / nTests;
    }
    
    int main()
    {
      double results[maxTests];
      long   nTests, nLoops;
    
      if(getValues(nTests, nLoops)) {
    
        long pass= 0;
        do {			
          cout <<  Test  << pass+1 << : ;
          runtest(nLoops, pass, results); // bzw. runtest2
          cout << results[pass] <<  Sekunden << endl;
          pass++;
        } while(pass < nTests);
    
        cout << endl <<  Mittelwert ;
        cout << (nTests == 1 ? des  : der );	
        cout << Tests:  << average(nTests, results) <<  Sekunden << endl << endl;
    
      } else
        cout <<  Falsche Eingabe, Programm wird beendet ... << endl << endl;
    
      return 0;
    }
    
     
  5. Aus dem anderen Thread:

    Code:
    void cursorxy(int x, int y) {
      COORD point;
      point.X = x; point.Y = y;
      SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);
    }
    
    Vielleicht hilft Dir das hier auch weiter:

    Konsolengröße (Screenbuffer) festlegen:
    Code:
    SMALL_RECT size;
    size.Top = 0;
    size.Left = 0;
    size.Bottom = height-1;
    size.Right = width-1;
    SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &size);
    COORD Sz;
    Sz.X = width;
    Sz.Y = height;
    SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), Sz);
    
    Cursor verstecken:
    Code:
    HANDLE hScreenBuf = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO cci;
    GetConsoleCursorInfo(hScreenBuf, &cci); 
    cci.bVisible= FALSE;
    SetConsoleCursorInfo(hScreenBuf, &cci);
    
    Das ist systemspezifisch, also gibt es das in C++ nicht ... Allerdings kannst Du unter Windows z.B. conio.h einbinden und die entsprechenden Windows-Funktionen benutzen. Wenn Du Zeichen ausgeben willst, ohne auf den nächsten Tastendruck zu warten, kannst Du _kbhit zusammen mit getch verwenden. So in der Art:

    Code:
    int getkey() {
      const int EXT1= 0, EXT2= 224;
      if(_kbhit()) {
        int input= getch();
        if((input == EXT1) || (input == EXT2))
          input= getch() << 8;
        return input;
      } else
        return kNone;
    }
    
    Die Definitionen:
    Code:
    
    #define kNone 0x0000
    
    /* Miscellaneous upper-left of keyboard */ 
    
    #define kESC    0x001b                  /* Escape                       */ 
    #define kTAB    0x0009                  /* Tab                          */ 
    
    /* Function keys F1 - F12 */ 
    
    #define kF1     0x3b00                  /* Function key 1               */ 
    #define kF2     0x3c00                  /* Function key 2               */ 
    #define kF3     0x3d00                  /* Function key 3               */ 
    #define kF4     0x3e00                  /* Function key 4               */ 
    #define kF5     0x3f00                  /* Function key 5               */ 
    #define kF6     0x4000                  /* Function key 6               */ 
    #define kF7     0x4100                  /* Function key 7               */ 
    #define kF8     0x4200                  /* Function key 8               */ 
    #define kF9     0x4300                  /* Function key 9               */ 
    #define kF10    0x4400                  /* Function key 10              */ 
    #define kF11    0x8500                  /* Function key 11              */ 
    #define kF12    0x8600                  /* Function key 12              */ 
    
    /* Shifted function keys F1 - F12 */ 
    
    #define ksF1    0x5400                  /* Shifted function key 1       */ 
    #define ksF2    0x5500                  /* Shifted function key 2       */ 
    #define ksF3    0x5600                  /* Shifted function key 3       */ 
    #define ksF4    0x5700                  /* Shifted function key 4       */ 
    #define ksF5    0x5800                  /* Shifted function key 5       */ 
    #define ksF6    0x5900                  /* Shifted function key 6       */ 
    #define ksF7    0x5a00                  /* Shifted function key 7       */ 
    #define ksF8    0x5b00                  /* Shifted function key 8       */ 
    #define ksF9    0x5c00                  /* Shifted function key 9       */ 
    #define ksF10   0x5d00                  /* Shifted function key 10      */ 
    #define ksF11   0x8700                  /* Shifted function key 11      */ 
    #define ksF12   0x8800                  /* Shifted function key 12      */ 
    
    /* Control function keys F1 - F12 */ 
    
    #define kcF1    0x5e00                  /* Control function key 1       */ 
    #define kcF2    0x5f00                  /* Control function key 2       */ 
    #define kcF3    0x6000                  /* Control function key 3       */ 
    #define kcF4    0x6100                  /* Control function key 4       */ 
    #define kcF5    0x6200                  /* Control function key 5       */ 
    #define kcF6    0x6300                  /* Control function key 6       */ 
    #define kcF7    0x6400                  /* Control function key 7       */ 
    #define kcF8    0x6500                  /* Control function key 8       */ 
    #define kcF9    0x6600                  /* Control function key 9       */ 
    #define kcF10   0x6700                  /* Control function key 10      */ 
    #define kcF11   0x8900                  /* Control function key 11      */ 
    #define kcF12   0x8a00                  /* Control function key 12      */ 
    
    /* Miscellaneous control keys: right side of keyboard */ 
    
    #define kBACK   0x0008                  /* Backspace                    */ 
    #define kENTER  0x000d                  /* Enter                        */ 
    #define kINS    0x5200                  /* Insert                       */ 
    #define kDEL    0x5300                  /* Delete                       */ 
    #define kHOME   0x4700                  /* Home                         */ 
    #define kEND    0x4f00                  /* End                          */ 
    #define kPGUP   0x4900                  /* Page Up                      */ 
    #define kPGDN   0x5100                  /* Page Down                    */ 
    
    /* Cursor keys */ 
    
    #define kUP     0x4800                  /* Cursor Up                    */ 
    #define kDOWN   0x5000                  /* Cursor Down                  */ 
    #define kLEFT   0x4b00                  /* Cursor Left                  */ 
    #define kRIGHT  0x4d00                  /* Cursor Right                 */ 
    
    /* Alternate miscellaneous keys: upper-left of keyboard */ 
    
    #define kaESC   0x0100                  /* Alternate Escape             */ 
    #define kaTAB   0xa500                  /* Alternate Tab                */ 
    #define kaBQUOT 0x2900                  /* Alternate ` or ~             */ 
    
    /* Alternate Function keys F1 - F12 */ 
    
    #define kaF1    0x6800                  /* Alternate Function key 1     */ 
    #define kaF2    0x6900                  /* Alternate Function key 2     */ 
    #define kaF3    0x6a00                  /* Alternate Function key 3     */ 
    #define kaF4    0x6b00                  /* Alternate Function key 4     */ 
    #define kaF5    0x6c00                  /* Alternate Function key 5     */ 
    #define kaF6    0x6d00                  /* Alternate Function key 6     */ 
    #define kaF7    0x6e00                  /* Alternate Function key 7     */ 
    #define kaF8    0x6f00                  /* Alternate Function key 8     */ 
    #define kaF9    0x7000                  /* Alternate Function key 9     */ 
    #define kaF10   0x7100                  /* Alternate Function key 10    */ 
    #define kaF11   0x8b00                  /* Alternate Function key 11    */ 
    #define kaF12   0x8c00                  /* Alternate Function key 12    */ 
    
    /* Alternate Numeric keys F1 - F12 */ 
    
    #define ka1     0x7800                  /* Alternate 1                  */ 
    #define ka2     0x7900                  /* Alternate 2                  */ 
    #define ka3     0x7a00                  /* Alternate 3                  */ 
    #define ka4     0x7b00                  /* Alternate 4                  */ 
    #define ka5     0x7c00                  /* Alternate 5                  */ 
    #define ka6     0x7d00                  /* Alternate 6                  */ 
    #define ka7     0x7e00                  /* Alternate 7                  */ 
    #define ka8     0x7f00                  /* Alternate 8                  */ 
    #define ka9     0x8000                  /* Alternate 9                  */ 
    #define ka0     0x8100                  /* Alternate 0                  */ 
    
    /* Alternate letter keys A - Z */ 
    
    #define kaA     0x1e00                  /* Alternate A                  */ 
    #define kaB     0x3000                  /* Alternate B                  */ 
    #define kaC     0x2e00                  /* Alternate C                  */ 
    #define kaD     0x2000                  /* Alternate D                  */ 
    #define kaE     0x1200                  /* Alternate E                  */ 
    #define kaF     0x2100                  /* Alternate F                  */ 
    #define kaG     0x2200                  /* Alternate G                  */ 
    #define kaH     0x2300                  /* Alternate H                  */ 
    #define kaI     0x1700                  /* Alternate I                  */ 
    #define kaJ     0x2400                  /* Alternate J                  */ 
    #define kaK     0x2500                  /* Alternate K                  */ 
    #define kaL     0x2600                  /* Alternate L                  */ 
    #define kaM     0x3200                  /* Alternate M                  */ 
    #define kaN     0x3100                  /* Alternate N                  */ 
    #define kaO     0x1800                  /* Alternate O                  */ 
    #define kaP     0x1900                  /* Alternate P                  */ 
    #define kaQ     0x1000                  /* Alternate Q                  */ 
    #define kaR     0x1300                  /* Alternate R                  */ 
    #define kaS     0x1f00                  /* Alternate S                  */ 
    #define kaT     0x1400                  /* Alternate T                  */ 
    #define kaU     0x1600                  /* Alternate U                  */ 
    #define kaV     0x2f00                  /* Alternate V                  */ 
    #define kaW     0x1100                  /* Alternate W                  */ 
    #define kaX     0x2d00                  /* Alternate X                  */ 
    #define kaY     0x1500                  /* Alternate Y                  */ 
    #define kaZ     0x2c00                  /* Alternate Z                  */ 
    
    /* Alternate miscellaneous symbol keys - right side of keyboard */ 
    
    #define kaMIN   0x8200                  /* Alternate - or _             */ 
    #define kaEQ    0x8300                  /* Alternate = or +             */ 
    #define kaLB    0x1a00                  /* Alternate [ or {             */ 
    #define kaRB    0x1b00                  /* Alternate ] or }             */ 
    #define kaBSL   0x2b00                  /* Alternate \ or |             */ 
    #define kaSC    0x2700                  /* Alternate ; or :             */ 
    #define kaQUOT  0x2800                  /* Alternate-> or                 */ 
    #define kaLT    0x3300                  /* Alternate , or <          */ 
    #define kaGT    0x3400                  /* Alternate . or >          */ 
    #define kaSLSH  0x3500                  /* Alternate / or ?             */ 
    
    /* Alternate miscellaneous control keys - right side of keyboard */ 
    
    #define kaBACK  0x0e00                  /* Alternate Backspace          */ 
    #define kaENTER 0x1c00                  /* Alternate Enter              */ 
    #define kaINS   0xa200                  /* Alternate Insert             */ 
    #define kaDEL   0xa300                  /* Alternate Delete             */ 
    #define kaHOME  0x9700                  /* Alternate Home               */ 
    #define kaEND   0x9f00                  /* Alternate End                */ 
    #define kaPGUP  0x9900                  /* Alternate Page Up            */ 
    #define kaPGDN  0xa100                  /* Alternate Page Down          */ 
    
    /* Alternate Cursor keys */ 
    
    #define kaUP    0x9800                  /* Alternate Cursor Up          */ 
    #define kaDOWN  0xa000                  /* Alternate Cursor Down        */ 
    #define kaLEFT  0x9b00                  /* Alternate Cursor Left        */ 
    #define kaRIGHT 0x9d00                  /* Alternate Cursor Right       */ 
    
    /* Alternate Numeric Keypad */ 
    
    #define kagSLASH        0xa400          /* Alternate /             */ 
    #define kagSTAR         0x3700          /* Alternate *             */ 
    #define kagMINUS        0x4a00          /* Alternate -             */ 
    #define kagPLUS         0x4e00          /* Alternate +             */ 
    #define kagENTER        0xa600          /* Alternate Enter         */ 
    
    /* Control + miscellaneous upper-left of keyboard */ 
    
    #define kcTAB           0x9400          /* Control Tab                  */ 
    
    /* Control + miscellaneous keys - right side of keyboard                */ 
    
    #define kcBACK          0x007f          /* Control Backspace            */ 
    #define kcENTER         0x000a          /* Control Enter                */ 
    #define kcINS           0x9200          /* Control Insert               */ 
    #define kcDEL           0x9300          /* Control Delete               */ 
    #define kcHOME          0x7700          /* Control Home                 */ 
    #define kcEND           0x7500          /* Control End                  */ 
    #define kcPGUP          0x8400          /* Control Page Up              */ 
    #define kcPGDN          0x7600          /* Control Page Down            */ 
    
    /* Control + Cursor keys */ 
    
    #define kcUP            0x8d00          /* Control Cursor Up            */ 
    #define kcDOWN          0x9100          /* Control Cursor Down          */ 
    #define kcLEFT          0x7300          /* Control Cursor Left          */ 
    #define kcRIGHT         0x7400          /* Control Cursor Right         */ 
    
    /* Control + keys on Numeric Keypad */ 
    
    #define kcgSLASH        0x9500          /* Control /               */ 
    #define kcgSTAR         0x9600          /* Control *               */ 
    #define kcgMINUS        0x8e00          /* Control -               */ 
    #define kcgPLUS         0x9000          /* Control +               */ 
    
    
     
  6. welche zeit gibt denn sleep an ?

    kannst du mir eine schleife zeigen die genau 1 sekunde wartet ?
    :)
     
  7. Sleep(1000);

    Der Thread wird damit für eine Sekunde angehalten; das ist also keine Schleife, die sinnlos Rechenzeit verbrät. Die Zeit wird in Millisekunden angegeben (1ms = 1/1000 Sekunde). Und, wie gesagt, es handelt sich um eine Windows-Funktion.
     
  8. also das mit der zeit habe ich jetzt so hinbekommen:

    Code:
    int time(void)
    {
     time_t zs;
     tm *nun;
     zs = time(0);
     nun = localtime(&zs);
     int minute = nun->tm_min;
     int stunde = nun->tm_hour;
     stunde *= 3600;
     minute *= 60;
    
     int zeit = stunde + minute + nun->tm_sec;
    
    
    
     return zeit;
    }
    ich konnte einfach nicht auf meine Sekunden seit Mitternacht verzichten.......

    das mit dem Cursorverschieben geht auch ganz gut....

    nur das mit der Tasteneingabe funktioniert nicht so ganz......

    wenn ich das hier ausführen will meckert mein Compiler rum:


    Programm:

    Code:
    #include <iostream.h>
    #include <windows.h>
    #include <winuser.h>
    #include <conio.h>
    
    
    using namespace std;
    
    int getkey() {
     const int EXT1= 0, EXT2= 224;
     if(_kbhit()) {
      int input= getch();
      if((input == EXT1) || (input == EXT2))
       input= getch() << 8;
      return input;
     } else
      return kNone;
    }
    
    
    void locate(int x, int y) {
     COORD point;
     point.X = x; point.Y = y;
     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);
    
    }
    
    int main()
    {
     HANDLE hScreenBuf = GetStdHandle(STD_OUTPUT_HANDLE);
     CONSOLE_CURSOR_INFO cci;
     GetConsoleCursorInfo(hScreenBuf, &cci);
     cci.bVisible= FALSE;
     SetConsoleCursorInfo(hScreenBuf, &cci);
    
     locate(12,12);
     cout << ;
     locate (12,12);
     cout << getkey();
    
     cin.get();
    
    
    
    
    
    
     return 0;
    }
    

    Fehlermeldung:
    cursor.cpp: E2451 Undefiniertes Symbol->kNone' in Funktion getkey() in Zeile 17
    cursor.cpp: E2268 Aufruf der undefinierten Funktion->_kbhit' in Funktion getkey() in Zeile 11
     
  9. Hmm ... oben bei den Definitionen:
    #define kNone 0x0000

    Dann schau mal nach, ob in Deiner conio.h _kbhit oder kbhit steht.
     
  10. ah danke, (in der conio.h stand kbhit statt _kbhit)

    so nun habe ich aber noch eine Frage: Wie kann man einzelne Zeichen vom Bildschirm mit C++ (und nicht mit den Augen) einlesen also praktisch etwa so:

    int a = getchar(x, y);

    x und y sind die Koordinaten des Zeichens , dass ausgelesen werden soll. a ist der ASCII wert des Zeichens.......