3. Dos.h funzt net :(

Dos.h funzt net :(

  • W

    Ja klar ist das falsch, das hab ich nur mal so runtergekritzelt und später in ruhe überarbeitet. Momentan sieht das ganze so aus:

    // Timer.hpp

#ifndef TIMER_HPP_
#define TIMER_HPP_

/* Benötigte Header */
#ifdef __WIN32__
   #include <windows.h> // Windows!
#else
   #include <unistd.h> // Linux, Mac OS & UNIX!
#endif

class Timer
{
private:
    int Time;
public:
    Timer();
    Timer(int Time);
    ~Timer();
    int getTime() const;
    void setTime(int Time);
    void setTimeNULL();
    void Start();
};

//----------> Konstruktoren <----------//
Timer::Timer()
{
}

Timer::Timer(int Time)
{
    this->Time = Time;
}

//----------> Destruktoren <----------//
Timer::~Timer()
{
}

//----------> Getter <----------//
int Timer::getTime() const
{
    return this->Time;
}

//----------> Setter <----------//
void Timer::setTime(int Time)
{
    this->Time = Time;
}

void Timer::setTimeNULL()
{
    this->Time = 0;
}

//----------> Andere <----------//
void Timer::Start()
{
    /* Funktion soll Systemunabhängig sein! */
    #ifdef __WIN32__
       Sleep(this->Time);
    #elif defined(_POSIX_VERSION)
       sleep(this->Time);
    #else
       #error "Unsupported platform."
    #endif
}

//---------->> ENDE <<----------//

#endif

    Dieser Code ist schon ausführbar...

    4. teilt man idr. zwischen *.h und *.cpp auf - *.hpp ist nicht so üblich, aber ich habs mal so gelassen... da man das so schön aufteilt, hat man jz die *.h schön zum mal schnell nachgucken, was gemacht wird und die *.cpp muss man nie wieder angucken - die includes werden somit auch in die *.cpp verschoben, weil du die net brauchst

    Na klar teile ich die auf, aber Leute die das Kopieren könnens selber aufteilen :p . Ich finde das lesserlich in einer Datei besser (Fürs Forum).
    Außer der Code ist lang dan sollte man schon aufgeteilt Posten...

    Mfg Wikinger75!

    0
  • U

    du hast offenbar noch immer nicht bemerkt, dass #error keine "" braucht...

    gut - damit bleiben nur noch 4 der 7 punkte... 🙄
    aber da dir es offensichtlich egal ist, brauch ich ja au nix mehr dazu sagen...

    bb

    0
  • W

    5. ist es doch hässlich, jedes mal wieder this-> vor member zu schreiben - und unnötig

    Ich wätte mal da sist einer der vier übrigen gründe... 😃
    Es ist eine frage des Still's ob man this-> benutzt oder weglässt, ich benutze ihn...

    Der Rest dürfte auch Still sein und jeden selbst überlassen.

    2. wozu eine fkt, wie SetTimeNULL?

    Wozu? Damit man ihn wieder auf Null setzen kann obwohl das wo du schon recht hast unsinnige Methode ist, aber ich hatte einfach mal lust^^ ( 🙄 )

    Mfg Wikinger75!

    0
  • U

    hmm.. hab gerad lange weile und mir is nix entspannteres eingefallen ^^

    #3
    http://de.wikipedia.org/wiki/Initialisierungsliste
    Ist leider ein wenig kurz und das wichtigste fehlt... Hier im Forum gabs das Thema aber mit Sicherheit schon öfters: Die Member werden mit I-Liste nicht erst default konstruiert, sondern es wird sofort der copy-CTor aufgerufen:

    bla::bla(T _member)
{
 member = _member;
}

    wird also zu so was in etwa:

    • erzeuge bla
    • rufe default-ctor von member auf
    • weise member einen neuen wert zu: _member

    in dem Fall könnte man auch schreiben:

    bla::bla(T _member)
: member(T())
{
 member = _member;
}

    also baut man es so:

    bla::bla(T _member)
: member (_member)
{}

    Es ist zwar am Anfang sehr ungewohnt aber mit der Zeit gewöhnt man sich nicht nur daran, es wird sogar sehr viel übersichtlicher...

    Ich denke auch nicht, dass der Compiler das wegoptimieren darf... Und bei const Werten bzw Referenzen hat man eh keine andere Wahl...

    #7
    http://opengroup.org/onlinepubs/007908799/xsh/usleep.html
    http://opengroup.org/onlinepubs/007908799/xsh/sleep.html

    Außerdem ist die Klasse immernoch unnötig...

    void MySleep(unsigned int milliseconds)
{
    #ifdef __Windows
      #include <windows.h>
      Sleep(milliseconds);
    #elif defined(_POSIX_VERSION)
      #include <unistd.h>
      if (milliseconds>= 1000) //nicht unbedingt nötig, aber würde imho lasterror überschreiben
          sleep(milliseconds/1000);
      if ((milliseconds%1000) / 1000) //noch mal
         usleep((milliseconds%1000)/1000);
    #else
      #error Not a supported platform
    #endif
}

    allerdings würde ich die fkt wohl Sleep nennen und die Fkt in nen namespace packen...

    Wenns nicht gerade ne Sleep-Fkt wäre, würd ich ja fast sagen, dass es bestimmt nen tolles Beispiel für inline-asm ist ^^

    Da bei nem Sleep die Zahlen eigentlich auch immer zur Compile-Zeit feststehen, könnte man mit templates sicherlich auch was schöneres für unix und ganze sekunden bzw. werte für unter 1s bauen...

    bb

    0
Anmelden zum Antworten