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

Grüssli

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

Ka gewohnheit^^
Mfg Wikinger75!

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

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

Mfg Wikinger75!

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.

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

Wo krieg ich einen guten fertigen Mechanismus her zum deleten ?

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

Wo krieg ich einen guten fertigen Mechanismus her zum deleten ?

häh? was willst du? Oo

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

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;

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_; }
};

Allerdings, wenn du alle Objekte aller Klassen damit verwalten willst, dann machst du was falsch. Ein boost::shared_ptr ist nicht die super Lösung zu allem, vor allem nicht wenn du nur zu faul bist, ein wenig selber zu überlegen. Dann wäre vielleicht eher ein Sprachwechsel optimal. Alternativen wären zum Beispiel Java oder C#.

Grüssli

Java macht aber keine Exe^^
C# was ich gar nicht, glaub aber dafür braucht man des NET Framework, das is
genauso kacke... Alles zu abhängig xD

Bei mir gibts mit C++ auch keine exe :p

Naja also ich finde sowas ist wirklich keine Empfehlung per se...
Für mein größtes Projekt habe ich sowas gemacht da ich an sehr sehr sehr sehr sehr vielen Stellen sonst hätte deleten müssen:

class sptr_target
{
      int eZugriffe;

protected:
      ptr_target() : eZugriffe(0) {}

      void registerUser() { eZugriffe++; }
      bool unregisterUser() { 
            if(!--eZugriffe) {
                 delete this;
                 return true;
            }
            return false;
      }

      friend class smart_ptr;
};

//T muss ableitung von sptr_target sein!
template<typename T>
class smart_ptr
{
      T* eTarget;

public:
      smart_ptr() : eTarget(0) {}
      //mehr sinnvolle CTors...

      smart_ptr& opertor=(sptr_target* t){
           if( eTarget != t ) return *this; //Sonst wird t gelöscht falls this einziger Pointer    

           if( eTarget ){
                eTarget->unregisterUser();
                eTarget = t;
                eTarget->registerUser();
          }
          return this;     
      }

      //Noch mehr operatoren wie -> * etc...

};

Daran gibt es mit Sichreheit viel auszusetzen aber es hat wundervoll funktioniert.
Dass es einen Heap-Zwang gibt ist sicher ...