3. problem Systemzeit + Countdowns

problem Systemzeit + Countdowns

  • M

    AxelH1992 schrieb:

    Hier mein Quelltext:

    int ZeitBuffer[4][3];

    @AxelH1992
    Ohne die Diskussion von gestern wieder aufwärmen zu wollen. Aber an der Stelle
    des Codes musste ich einfach lachen. Weist du wie man dieses "Konstrukt" was du
    da hast nennt?!

    Zu deiner 2. Frage. Dazu musst du die Zeiten in das obige "Konstrukt" eingeben,
    jedoch bist du dann auf maximal 4 Countdowns begrenzt. Am einfachsten würde
    es funktionieren wenn du anstatt diesem "Konstrukt" einen std::vector nimmst.
    Dieser "Datentyp" wird automatisch größer wenn du mehr Werte einlesen willst.
    Google einfach mal danach und lese dich ein wenig darin ein. Das wird dich
    dann schnell weiterbringen denke ich.

    ~Um diesen Post zu verstehen muss man die bisherigen Posts des OP kennen.~

    0
  • V

    lol

    0

  • Weist du wie man dieses "Konstrukt" was du
    da hast nennt?!

    Hmmm...

    This ... is the Construct.
    It's our loading program.
    We can load anything, from clothing ... to equipment ... weapons ... training simulations ... anything we need.

    😃

    ~Musste da nur gerade dran denken, weil man ein solches "Konstrukt" ja auch manchmal als~ Matrix bezeichnet.

    0
  • O

    Threads sind schon eine verdammt kreative Lösung...

    0
  • D

    😃

    0
  • D

    lol

    0
  • ?

    Shick ich später zu www.thedailywtf.com

    0
  • U

    ach menno, jz habt ihr ihn ganz verjagt 😞

    0
  • D

    So Axel hier ist jetzt mal eine Version die auch funktioniert, allerdings ist nur unter Linux getestet, sollte aber ohne große Probs. auf dem C++ Builder von Borland laufen, dafür einfach das #define CBUILDER auskommentieren.

    Wenn eine(r) den C++ Builder hat kann er das ja mal auf seinem System testen. Ich gehe jetzt ins Bett, gute Nacht... 🙂

    // nächste Zeile auskommentieren wenn auf Borland C++ kompilliert wird
// #define CBUILDER

#ifdef CBUILDER
  #pragma hdrstop
#endif
#include <iostream>
#include <sstream>
#include <iomanip>
#include <ctime>
#include <cstdlib>
#include <stdio.h>
#ifdef CBUILDER
 #include <conio.h>
#endif

using namespace std;
//---------------------------------------------------------------------------

/** Konstantendefinitionen besser an den Anfang **/
// enthält die Pausenzeiten
const int ZeitBuffer[ ][3] = {{ 9,05,00},
                              {10,55,00},
                              {12,40,00},
                              {14,30,00}};

// std::vector<string> auch möglich - string aber nicht dynamisch
const string Zustand [ ] = { "Erste Pause: " ,
                             "Zweite Pause: ",
                             "Dritte Pause: ",
                             "Schulschluss: " };

/** @name   AktuellesDatum
 *  @return string :  aktuelles Datum und Zeit im Format
 *                    DD.MM.YYYY - HH:NN:SS
 *  @param  tm* timeinfo : aktuelle lokale Zeit
 **/
string AktuellesDatum(tm* timeinfo)
{
        ostringstream out;
        // Anpassen der Zeichenbreite und festlegen Füllzeichen
        // setw und setfill
        out << setw(2) << setfill('0') << timeinfo->tm_mday << '.'
            << setw(2) << setfill('0') << timeinfo->tm_mon+1 << '.'
            << timeinfo->tm_year + 1900 << " - "
            << setw(2) << setfill('0') << timeinfo->tm_hour << ':'
            << setw(2) << setfill('0') << timeinfo->tm_min << ':'
            << setw(2) << setfill('0') << timeinfo->tm_sec;
        return out.str();
}

/** IstAktuellePause()
 *  Prüft ob die aktuelle Zeit noch vor der Pausenzeit liegt
 *  @return bool :  Diese Pause ist die aktuelle nächste Pause
 *  @param  const int* : Array von Pausenzeit-Daten
 *  @param  tm* timeinfo : aktuelle lokale Zeit
 **/

bool IstAktuellePause(const int Buffer[], tm* timeinfo)
{
    return ( ( Buffer[0] * 3600 + Buffer[1] * 60 + Buffer[2]) >
             ( timeinfo->tm_hour * 3600 + timeinfo->tm_min * 60 +
               timeinfo->tm_sec ) );
}

/** Restzeit()
 *  @return string :  Die Zeit bis zur nächsten Pause von 00:00:00 Uhr an,
 *                    berechnet aus Pausenzeit-Daten
 *  @param  const int* : Array von Pausenzeit-Daten
 *  @param  tm* timeinfo : aktuelle lokale Zeit
 **/

string Restzeit(const int Buffer[], tm* timeinfo)
{
    ostringstream out;
    int min, sec;

    // lässt sich noch optimieren... z.B mit Abfrage auf negative Werte
    min = ( (Buffer[1] > timeinfo->tm_min) ?
            (Buffer[1] - timeinfo->tm_min) : (Buffer[1] - timeinfo->tm_min + 60 ) );

    sec = ( (Buffer[2] > timeinfo->tm_sec) ?
            (Buffer[2] - timeinfo->tm_sec) : (Buffer[2] - timeinfo->tm_sec + 60 ) );

    // Anpassen der Zeichenbreite und festlegen Füllzeichen
    // setw und setfill
    out << setw(2) << setfill('0') << ( Buffer[0] - timeinfo->tm_hour ) << ":"
        << setw(2) << setfill('0') << ( min  )  << ":"
        << setw(2) << setfill('0') << ( sec  );
    return out.str();
}

/** ZeitBisPause()
 *  @return string :  Die Zeit bis zur nächsten Pause
 *  @param  tm* timeinfo : aktuelle lokale Zeit
 **/

 string ZeitBisZurPause(tm* timeinfo)
 {
        ostringstream out;
        for (int i = 0; i < 4; i++)
          if (IstAktuellePause(ZeitBuffer[i], timeinfo))
          {
            out << Zustand[i] << " noch " << Restzeit(ZeitBuffer[i], timeinfo);
            return out.str();
          }

        out << "Schule is aus...";
        return out.str();
 }

#ifdef CBUILDER
  #pragma argsused
#endif
int main(int argc, char* argv[])
{

time_t rawtime;
tm *timeinfo;
int oldtime;

/** schleifen anfang hier **/
#ifdef CBUILDER
  // windows variante
  while (!kbhit())
#else
  // linux variante
  while(1)
#endif
  {
    rawtime = time(0) ;
    timeinfo = localtime(&rawtime);  // gibt einen Pointer auf eine statische
                                     // Struktur zurück NICHT freigeben!

    // Aktualisierung im Sekundentakt
    if (timeinfo->tm_sec != oldtime)
    {
    #ifdef CBUILDER
      clrscr();         // c builder
      // system("clr"); // in windows würde diese variante auch gehen
      cout << "Abbruch mit bel. Taste" << endl;
    #else
      system("clear"); // posix variante
      cout << "Abbruch mit [CTRL-C]" << endl;
    #endif

    cout << AktuellesDatum (timeinfo) << endl;
    cout << ZeitBisZurPause(timeinfo) << endl;

    // Sekunde für den nächsten Zeitvergleich speichern
    oldtime = timeinfo->tm_sec;
    }
  }
  /** schleifen ende hier **/

  #ifdef CBUILDER
    getch();  // Fenster offenhalten - DEBUG
  #endif
  return 0;
}
    0
  • A

    Also meinen Quelltext habt ihr ja schon gesehen. Der basiert natürlich darauf, dass der Benutzer nicht erst noch die Anzahl der Countdowns und die Endzeit der Countdowns eingibt, sondern schon 4 Countdowns existieren.

    Funktioniert auch soweit, nur habe ich in der Rechnung (denke ich) noch irgendwo Probleme, denn ich bekomme ja die Systemzeit in Echtzeit ausgegeben, und darunter dann je einen Countdown.
    So, jetzt kann ich ja anhand meiner Endzeit dieses Countdowns (die ich ja weiss) und anhand der Echtzeit-Ausgabe der Systemzeit ausrechnen, was dann beim Countdown stehen müsste.

    Aber da habe ich folgendes Probelm:

    Bei den Sekunden des Countdowns habe ich permanent einen Minuswert, und der ist identisch mit dem Sekundenwert der Systemzeit. (Systemzeit= 50 / Countdown= -50)

    bei den Minuten gibt es so ziemlich das selbe Problem:
    Ihr seht ja in meinem Quelltext, der erste Countdown hat die Endzeit 9:05:00
    Jetzt ist folgendes in der Ausgabe der Fall:
    Systemzeit= 4:8:40 / Countdown= 5:-3:-40

    8-3=5, das sind die 5 Minuten aus der Endzeit des Countdowns, aber warum erscheint das in der Ausgabe hinterher dann so seltsam??

    Sofern ich dieses Problem (hoffentlich mit eurer Hilfe) beheben konnte,
    würde ich ganz gern folgende modifizierungen einbauen:

    -Keine vorbestimmten Countdowns, sondern der Benutzer soll erst bestimmen wie viele Countdowns es geben soll, und definiert diese dann danach (gibt dessen Endzeiten in Std/Min/Sek ein), ODER
    -Der Benutzer wird ein Mal aufgefordert einen Countdown in Std/Min/Sek zu definieren und wird dann (mit einer Schleife) gefragt, ob er einen weiteren einfügen möchte.

    Was bei mir funktioniert:
    -Die Systemzeit wird tadellos in Echtzeit ausgegeben
    -Die Countdowns werden nicht ALLE 4 angezeigt, sondern immer nur der, der als nächstes abläuft
    -Wenn ein Countdown abläuft, verschwindet dieser und der nächste tritt an die Stelle des vorherigen Countdowns

    Ich könnte mir zu meinen geplanten Modifizierungen schon was vorstellen, von dem ich mir erhoffe dass es funktioniert, aber das probiere ich erstmal aus bevor ich es einbaue.

    Ich bitte um Lösungsvorschläge zu meinem Problem mit der Ausgabe, und Vorschläge für den Einbau meiner geplanten Modifikation.

    Bitte versucht so wenig wie möglich Neues einzubringen, versucht den vorhandenen Quelltext zu "verändern" (wenn möglich), ok?

    Danke im Vorraus, und wie immer mfG, Axel 🙂

    Edit: hier nochmal der Quelltext

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

#pragma hdrstop
#include <iostream>
#include <ctime>
#include <time.h>
#include <stdlib>
#include <stdio.h>
#include <conio.h>
using namespace std;

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

#pragma argsused
int main(int argc, char* argv[])
{

int ZeitBuffer[4][3];

	ZeitBuffer[0][0] = 9;
	ZeitBuffer[0][1] = 05;
	ZeitBuffer[0][2] = 00;

	ZeitBuffer[1][0] = 10;
	ZeitBuffer[1][1] = 55;
	ZeitBuffer[1][2] = 00;

	ZeitBuffer[2][0] = 12;
	ZeitBuffer[2][1] = 40;
	ZeitBuffer[2][2] = 00;

	ZeitBuffer[3][0] = 14;
	ZeitBuffer[3][1] = 30;
	ZeitBuffer[3][2] = 00;

time_t Zeitstempel;
tm *nun;

int altezeit;
while (!kbhit())
{
	Zeitstempel = time(0) ;
	nun = localtime(&Zeitstempel);

	if (nun->tm_sec != altezeit)
	{
	clrscr();
	cout<<nun->tm_mday<<'.'<<nun->tm_mon+1<<'.'<<nun->tm_year+1900<<" - "<<nun->tm_hour<<':'<<nun->tm_min<<':'<<nun->tm_sec<<endl;

	if ((ZeitBuffer[0][0]-nun->tm_hour > 0) || (ZeitBuffer[0][1]-nun->tm_min > 0) || (ZeitBuffer[0][2]-nun->tm_sec > 0))
	cout << "Erste Pause: noch " << ZeitBuffer[0][0]-nun->tm_hour << ":" << ZeitBuffer[0][1]-nun->tm_min << ":" << ZeitBuffer[0][2]-nun->tm_sec;

else if ((ZeitBuffer[1][0]-nun->tm_hour > 0) || (ZeitBuffer[1][1]-nun->tm_min > 0) || (ZeitBuffer[1][2]-nun->tm_sec > 0))
	cout << "Zweite Pause: noch " << ZeitBuffer[1][0]-nun->tm_hour << ":" << ZeitBuffer[1][1]-nun->tm_min << ":" << ZeitBuffer[1][2]-nun->tm_sec;

else if ((ZeitBuffer[2][0]-nun->tm_hour > 0) || (ZeitBuffer[2][1]-nun->tm_min > 0) || (ZeitBuffer[2][2]-nun->tm_sec > 0))
	cout << "Dritte Pause: noch " << ZeitBuffer[2][0]-nun->tm_hour << ":" << ZeitBuffer[2][1]-nun->tm_min << ":" << ZeitBuffer[2][2]-nun->tm_sec;

else if ((ZeitBuffer[3][0]-nun->tm_hour > 0) || (ZeitBuffer[3][1]-nun->tm_min > 0) || (ZeitBuffer[3][2]-nun->tm_sec > 0))
	cout << "Schulschluss: noch " << ZeitBuffer[3][0]-nun->tm_hour << ":" << ZeitBuffer[3][1]-nun->tm_min << ":" << ZeitBuffer[3][2]-nun->tm_sec;

else
	cout << "Schule is aus...";

	altezeit = nun->tm_sec;
	}
}

getch();

	return 0;
}
//---------------------------------------------------------------------------
    0
  • A

    Danke, DeepCopy, ich werde das mal ausprobieren.
    Und, auch wenn es ein wenig beschämend für mich ist, dass du meine Aussage über int und float in deine Signatur gepackt hast, auch danke dafür. ^^
    Naja ich bleibe dennoch dabei, unser Proggen lehrer hat es uns so vermittelt, ich wende das dann auch so an, es sei denn, jemand belehrt mich mit einem praktischen Beispiel eines Besseren 😉

    (Soll jetzt keine Anregung sein, mir praktische Beispiele zu vermitteln ;))

    Danke nochmal, mfG, Axel

    Edit:

    DANKE DEEPCOPY 😃

    Dein Quelltext hat mich grad sozusagen erleuchtet !!!
    Ich habe ihn sogar verstanden 😃

    Vielen Dank, du bist ein Meister!

    *Huldigt ihm*

    So ich muss um 5 raus also werde ich noch ein wenig "Ant Me!" lesen und dann zur Schule pilgern 🙂
    Euch Allen ne gute Nacht und erholsame C++ Träume 😉

    MfG, Axel

    0
  • V

    Du hast cout.flush(); direkt nach cout<<endl; nur einmal aufgerufen. Man muß cout.flush(); aber nach cout<<endl; dreimal aufrufen, um notwendige Interferenzen zu vermeiden.

    0
  • D

    volkard schrieb:

    Du hast cout.flush(); direkt nach cout<<endl; nur einmal aufgerufen. Man muß cout.flush(); aber nach cout<<endl; dreimal aufrufen, um notwendige Interferenzen zu vermeiden.

    Kannst du mir dafür ein Beispiel nennen? Ich hatte es in der Vorlesung so verstanden, wenn cout.flush() aufgerufen wird ist der Buffer garantiert leer.

    EDIT: Im obigen Code geändert!

    AxelH1992 schrieb:

    Dein Quelltext hat mich grad sozusagen erleuchtet !!!
    Ich habe ihn sogar verstanden 😃

    Das freut mich, achte mal die Unterschiede in der Funktion zur Berechnung wann die nächste Pause anfängt, die funktioniert in deiner Version überhaupt nicht richtig, verändere mal "On The Fly - während das Programmläuft" das Systemdatum von z.B. 23:50 auf 00:50, dann siehst du was ich meine, was dein Programm anzeigt hängt vom Zufall der gewählten Pausenzeit ab.

    AxelH1992 schrieb:

    -Wenn ein Countdown abläuft, verschwindet dieser und der nächste tritt an die Stelle des vorherigen Countdowns

    Nein leider nicht, warum siehe weiter oben, achte in deiner Version auch mal auf die Berechnung der Restzeit und verändere mal "On The Fly" die Systemzeit dabei, du wirst feststellen das diese nur dann Negativ für Minuten und Sekunden ist wenn die aktuelle Zeit für Minuten und Sekunden größer ist als die Pausenzeit für Minuten und Sekunden.

    AxelH1992 schrieb:

    Vielen Dank, du bist ein Meister!

    Danke, das gebe ich gleich mal weiter an: volkard, Nexus, camper, unskilled, SP, .... und alle die ich vergessen habe...
    nein wirklich das sind DIE Grundlagen von denen ich gesprochen habe, ein paar Schleifen, in bisschen cin und cout, einfache Datentypen, Arrays, ein paar Funktionsaufrufe fertig. Keine Klassen, keine Vererbung, keine Konstruktoren, keine überladnenen Operatoren, kein STL, kein TR1, keine Pointer-Arithmetik, keine Allokation ... usw. usw. usw...

    Mach mal weiter du bist auf dem "Richtigen Weg" 👍

    0
  • V

    DeepCopy schrieb:

    volkard schrieb:

    Du hast cout.flush(); direkt nach cout<<endl; nur einmal aufgerufen. Man muß cout.flush(); aber nach cout<<endl; dreimal aufrufen, um notwendige Interferenzen zu vermeiden.

    Kannst du mir dafür ein Beispiel nennen? Ich hatte es in der Vorlesung so verstanden, wenn cout.flush() aufgerufen wird ist der Buffer garantiert leer.

    Den Teil hast Du richtig verstanden. Nur bei endl fehlt was ganz entscheidendes. Eigentlich wollte ich sagen, daß man nach endl nicht EINMAL flushen soll, wie Du es dort getan und für das einzig Wahre dargestellt hast.

    cout << ZeitBisZurPause(timeinfo) << endl;

    /** Wichtig! **/
    cout.flush(); // Den output-Buffer vollständig leeren
                  // (alles auf die Konsole schreiben)

    Mit http://www.cplusplus.com/reference/iostream/manipulators/endl/ kommst Du bestimmt in Sekunden drauf, warum ich dort lachen mußte.

    ~Nimm int oder float. Aber aufpassen, immer nur einen dieser Datentypen pro Programm benutzen, sonst vertut sich der Compiler ganz gerne mal.~

    0
  • D

    AxelH1992 schrieb:

    Und, auch wenn es ein wenig beschämend für mich ist, dass du meine Aussage über int und float in deine Signatur gepackt hast, auch danke dafür. ^^
    Naja ich bleibe dennoch dabei, unser Proggen lehrer hat es uns so vermittelt, ich wende das dann auch so an, es sei denn, jemand belehrt mich mit einem praktischen Beispiel eines Besseren 😉

    Dazu siehe dir mal folgendes Beispiel an!

    #include <iostream>

using namespace std;

int main()
{
    // im Groben die einfachen nummerischen Typen
    char         a = 'a';
    short       si = 1;
    int          i = 2;
    long         l = 3;
    long long   ll = 4;
    float        f = 5.0f;
    double       d = 7.0f;
    long double ld = 8.0L;

    cout << "Int, Float und die einfachen nummerischen Typen! (nicht vollständig)" << endl << endl;
    cout << "        char a = [" << a  << "] und belegt (" << sizeof(a)  << ") Byte Speicher" << endl;
    cout << "      short si = [" << si << "] und belegt (" << sizeof(si) << ") Byte Speicher" << endl;
    cout << "         int i = [" << i  << "] und belegt (" << sizeof(i)  << ") Byte Speicher" << endl;
    cout << "        long l = [" << l  << "] und belegt (" << sizeof(l)  << ") Byte Speicher" << endl;
    cout << "  long long ll = [" << ll << "] und belegt (" << sizeof(ll) << ") Byte Speicher" << endl;
    cout << "       float f = [" << f  << "] und belegt (" << sizeof(f)  << ") Byte Speicher" << endl;
    cout << "      double d = [" << d  << "] und belegt (" << sizeof(d)  << ") Byte Speicher" << endl;
    cout << "long double ld = [" << ld << "] und belegt (" << sizeof(ld) << ") Byte Speicher" << endl;
    cout << endl;
    cout << "Und ich hab mich nicht mal vertan! :) "  << endl;

    // cout.flush() nicht notwendig wird wegen endl oder cin automatisch gemacht
    cin >> i; // nur für DEBUG

    return 0;
}

    Und das ist die Ausgabe auf meinem System (Linux 64bit)

    Int, Float und die einfachen nummerischen Typen! (nicht vollständig)

        char a = [a] und belegt (1) Byte Speicher
      short si = [1] und belegt (2) Byte Speicher
         int i = [2] und belegt (4) Byte Speicher
        long l = [3] und belegt (8) Byte Speicher
  long long ll = [4] und belegt (8) Byte Speicher
       float f = [5] und belegt (4) Byte Speicher
      double d = [7] und belegt (8) Byte Speicher
long double ld = [8] und belegt (16) Byte Speicher

Und ich hab mich nicht mal vertan! :)
    0
  • D

    volkard schrieb:

    Den Teil hast Du richtig verstanden. Nur bei endl fehlt was ganz entscheidendes. Eigentlich wollte ich sagen, daß man nach endl nicht EINMAL flushen soll, wie Du es dort getan und für das einzig Wahre dargestellt
    hast.

    Daran konnte ich mich gar nicht mehr erinnern so um 4 Uhr morgens 😃 Danke!

    cout.flush() war auch nur drin wegen dem ursprünglichen Code von Alex da hat's dann am Ende geknallt. Und die Reihenfolge bei der nächsten Ausgabe war vertauscht.

    Merci für den Tipp 🙂

    0
  • V

    Nur weils später bei den Factories so nett ist, den # zu haben:

    #include <iostream>
#include <cstring>

using namespace std;

#define TEST(TYP,NAME,WERT) \
	TYP NAME = WERT; \
	cout << "           "+strlen(#TYP) << #TYP << "   "+strlen(#NAME) << #NAME " = [" << NAME << "] und belegt (" << sizeof(NAME)  << ") Byte Speicher\n" ;

int main()
{
	// im Groben die einfachen nummerischen Typen
	cout << "Int, Float und die einfachen nummerischen Typen! (nicht vollständig)" << endl << endl;
	TEST(char,a,'a');
	TEST(short,si,1);
	TEST(int,i,3);
	TEST(long,l,3);
	TEST(long long,ll,4);
	TEST(float,f,5.0);
	TEST(double,d,7.0);
	TEST(long double,ld,8.0L);
	cout << '\n';
	cout << "Und ich hab mich nicht mal vertan! :) \n";

	cin.get();

	return 0;
}
    0
  • D

    😃

    0
  • D

    Die Sache will mir einfach nicht aus dem Kopf, was macht der jetzt mit dem von mir geschriebenen Programm, geht er jetzt hin und erklärt seinen Schülern wie ein Profi, so wie er einer ist, das macht? Es muss einfach schmunzeln...

    oder hat es ihn jetzt wirklich überzeugt? Wenn ich den letzen Post von ihm sehe wollte er doch noch dynamisch die Pausen festlegen (so profimässig halt 🙂 ), und jetzt meldet er sich nicht mal mehr... schade :p

    0
Anmelden zum Antworten