TimingTool

Wikinger75

Hey Leute.
Hab mir mal ein kleines TimingTool gemacht, welches System unabhängig laufen soll.
Habs unter Windows ausprobiert und da läuft es vernüptig und au so wie es soll.

Meine Fragen:
1.) Wenn ihr ein anderes System als Windows habt probiert das mal bitte aus, obs auch da Funktioniert^^

2.) Was halltet ihr von dem Code?

Kleine Anmerkung:
Die Zeitangabe wird dem Timer in Minuten übergeben^^

So hier mal der Code.
Hab die Klassen definition von der declaration getrennt.

Timer.hpp

// Timer.hpp
#ifndef TIMER_HPP_
#define TIMER_HPP_

#ifdef __WIN32__
   #include <windows.h>
#elif defined(_POSIX_VERSION)
   #include <unistd.h>
#else
   #error Unsupported platform!
#endif

template <class T>
class Timer
{
private:
    T Time;
public:
    Timer();
    Timer(T Time);
    ~Timer();
    T getTime() const;
    void setTime(T Time);
    void Start();
};

#include "TimerDef.hpp"

// Vordefinierte Timer
typedef Timer<int> nTimer;
typedef Timer<double> dTimer;

#endif // TIMER_HPP_

TimerDef.hpp

// TimerDef.hpp
#ifndef TIMER_DEF_HPP_
#define TIMER_DEF_HPP_

//----------> Konstruktoren <----------//
template <class T>
Timer<T>::Timer()
{
}

template <class T>
Timer<T>::Timer(T Time)
{
    this->Time = Time;
}

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

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

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

//----------> Andere <----------//
template <class T>
void Timer<T>::Start()
{
    #ifdef __WIN32__
       Sleep(this->Time*60*1000);
    #elif defined(_POSIX_VERSION)
       sleep(this->Time*60*1000);
    #else
       #error Unsupported platform!
    #endif
}

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

#endif // TIMER_DEF_HPP_

Falls ihr das ausprobieren wollt unter dem anderem System oder kucken wollt obs läuft hab ich auch ne Main.cpp dazu gebastelt, is ja au klar zum ausprobieren obs überhaupt geht^^

Main.cpp

#include <iostream>
#include "Timer.hpp"
using namespace std;

int main()
{
    cout << "Start des Programmes" << endl;
    cout << "Zeit Stellen..." << endl;

    nTimer* UHR = new nTimer(1);

    cout << "Läuft über in den Schlaf-Modus..." << endl;

    UHR->Start();

    cout << "Schlaf-Modus Beendet!" << endl;

    return 0;
}

Freu mich auf eure Antworten!
Mfg Wikinger75

Dravere

1. Das gehört eher ins Projekt Forum.
2. Du kapselst Sleep mit einem undeutlichen Namen.
3. Ein Timer schläft nicht, wenn ich ihn starte, sondern gibt mir in Intervallen Signale.
4. Wenn wir gerade den Start erwähnen, die Funktion dürfte wohl konstant sein.
5. Wenn man Timer<double> verwendet, bekommt man mit Sicherheit eine Warnung, wegen der Konvertierung von double zu int.
6. Präprozessor Anweisungen im Code sind sehr unschön, gab erst letztens ein Thread dazu.
7. Wieso legst du den Timer in der main Funktion per new an? Auf dem Stack hätte da gereicht.
8. Meisterleistung, wie lange hast daran gearbeitet? 5 Minuten?
9. Leg dir ein Linux zu, kannst ja über GRUB ein Dual-Boot machen, dann kannst du selber testen.
10. Ich schliesse mich meinem Vorgänger an ->

Grüssli

Ganz toll :eek

lolololo

Wikinger75

Irgentwie muss man doch auf das System prüfen und das ist halt eben nur durch Präprosezor anweisung machbar^^
Hmm naja stimmt Timer ist ein wenig doof.
Hmm wenn double nit geht kann ich ja aus der ne Normale Klasse machen nua mit int wenns bei double nen error gibt^^

Warum ich das per new mache?
Ka gewohnheit^^
Mfg Wikinger75!

Wikinger75 schrieb:

Ka gewohnheit^^
Mfg Wikinger75!

Warum es Memory Leak, Segfaults und Buffer overflow gibt?
JA KLAR! GEWOHNHEIT!

Dravere

Wikinger75 schrieb:

Irgentwie muss man doch auf das System prüfen und das ist halt eben nur durch Präprosezor anweisung machbar^^

Lies was ich gesagt habe. Ich sagte Präprozessor im Code sei schlecht nicht Präprozessor an sich. Man lagert solche Dinge aus. Ich habe mal den Thread rausgesucht:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-236515.html

Startet mit etwas anderem, aber geht schnell ins entsprechende Thema über.

Wikinger75 schrieb:

Hmm wenn double nit geht kann ich ja aus der ne Normale Klasse machen nua mit int wenns bei double nen error gibt^^

Nochmals, lies was ich gesagt habe. Es gibt keinen Fehler sondern eine Warnung. Aber sag mal, hast du das nicht mal probiert? Hast du überhaupt die jeweiligen Dokumentationen zu Sleep gelesen? Man könnte fast soweit gehen, hast du dir überhaupt was überlegt?

Wikinger75 schrieb:

Warum ich das per new mache?
Ka gewohnheit^^

Dann gewöhn dir immerhin an, dass man zu jedem new ein delete macht.

Ich frag mich mehr und mehr, was das eigentlich soll.

Grüssli

Wikinger75

Hmm joa eigentlich schon^^
Ich hab das delete vergesen, weil ich das von wx her gewohnt bin...
Hmm guter Thread...
Kapier aber nicht wirklich das schlimme dadran...
Ich glaub wir lassens hier einfach ma^^

Mfg Wikinger75!

knivil

Was soll Timer eigentlich machen?

Wenn ihr ein anderes System als Windows habt probiert das mal bitte aus, obs auch da Funktioniert^^

Installiere doch einfach Linux oder so in einer virtuellen Maschine.

xBlackKnightx

es gibt noch memory leaks wenn das programm beendet wird? dachte windows räumt das automatisch auf?

Firefighter

Ist das Ernst gemeint? Na dein Code will ich nicht sehen! Zu jedem new gehört ein delete, es gibt keine Gewissheit wann und ob überhaupt das OS deinen Speicher freigibt welchen du mal angefordert hast.

xBlackKnightx

komisch dass ich in Qt Anwendungsbeispiele noch nie delete Schlüsselwort gesehen hab, aber lauter new-Schlüsselwörter. Anscheinend räumt Qt das alles automatisch auf

Dravere

xBlackKnightx schrieb:

komisch dass ich in Qt Anwendungsbeispiele noch nie delete Schlüsselwort gesehen hab, aber lauter new-Schlüsselwörter. Anscheinend räumt Qt das alles automatisch auf

Die meisten QT Objekte haben wie die meisten wxWidgets Objekte einen Referenzzähler dahinter. Daher muss man sie sogar per new anlegen, sonst gibt es massives undefiniertes Verhalten. Diese Objekte werden dann automatisch per delete freigegeben.
Aber wenn du ein Objekt von einer eigenen Klasse, wie hier zum Beispiel der Timer, erstellst, dann musst du den auch selber freigeben. Das ist unter QT nicht anders.

Wieder mal ein typisches Beispiel, wieso man zuerst richtig C++ lernen sollte, bevor man an die GUI Programmierung oder ähnliches geht ...

Grüssli

xBlackKnightx

hm äh ich hätt schon gern einen sauberen code. C++ Grundlagen lesen hab ich schon, nur kann ich mir nicht alles merken.

Wo krieg ich einen guten fertigen Mechanismus her zum deleten ?

Und die Klassen die ich neu definiere, müssen nur von diesem erben?

unskilled

Wo krieg ich einen guten fertigen Mechanismus her zum deleten ?

häh? was willst du? Oo

xBlackKnightx schrieb:

hm äh ich hätt schon gern einen sauberen code. C++ Grundlagen lesen hab ich schon, nur kann ich mir nicht alles merken.

Wo krieg ich einen guten fertigen Mechanismus her zum deleten ?

Und die Klassen die ich neu definiere, müssen nur von diesem erben?

object_name* object = new object_name();

//mach was damit

delete object_name;

fang erstmal damit an und poste nicht so einen käse :p

Wikinger75

Ich glaube eher er wollte wissen wie der mechanismus bei wx und qt geht also wie man so was machen kann das man new machen muss aber selber dan kein delete mehr

volkard

jhonnyDeppe schrieb:

object_name* object = new object_name();
//mach was damit
delete object_name;
fang erstmal damit an und poste nicht so einen käse :p

:p
auch nicht schlecht wäre

object_name* object = new object_name();
//mach was damit
delete object;

xBlackKnightx

Ich will alle Klassen da reinbinden. Damit ich nicht mehr um delete kümmern muss. Sowas ist langweilig. Sowas wie das hier, aber es soll besseres geben. Wo nur?

template <class T> class refcnt_ptr {
protected:
    // a helper class that holds the pointer to the managed object
    // and its reference count
    class Holder {
    public:
        Holder( T* ptr) : ptr_(ptr), count_(1) {};
        ~Holder() { delete ptr_;};

        T* ptr_;
        unsigned count_;
    };

    Holder* h_;

public:
    // ctor of refcnt_ptr (p must not be NULL)
    explicit refcnt_ptr( T* p) : h_(new Holder(p)) {}
    // dtor of refcnt_ptr
    ~refcnt_ptr() { if (--h_->count_ == 0) delete h_; }
    // copy and assignment of refcnt_ptr
    refcnt_ptr (const refcnt_ptr<T>& right) : h_(right.h_) {
        ++h_->count_;
    }
    refcnt_ptr<T>& operator= (const refcnt_ptr<T>& right) {
        ++right.h_->count_;
        if (--h_->count_ == 0) delete h_;
        h_ = right.h_;
        return *this;
    }
    refcnt_ptr<T>& operator= (refcnt_ptr<T>& right) {
        ++right.h_->count_;
        if (--h_->count_ == 0) delete h_;
        h_ = right.h_;
        return *this;
    }
    // access to the managed object
    T* operator-> () { return h_->ptr_; }
    T& operator* ()  { return *h_->ptr_; }
};