TimingTool

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

knivil

Nennt sich Garbage Collection. Aber vielleicht ist die Sprache Java eher was fuer dich.

Firefighter

Oder du nutzt die boost shared_ptr

Dravere

Wie Firefighter sagt, Boost.SmartPr und daraus den shared_ptr :
http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/smart_ptr.htm

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

xBlackKnightx

weil es sonst quick&dirty wäre?

Wikinger75

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

Wikinger75 schrieb:

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 ...

Dravere

xBlackKnightx schrieb:

weil es sonst quick&dirty wäre?

Nicht nur, sondern zum Teil auch langsam und nicht immer Threadsafe. Du zerstörst Vorteile von C++ damit. Zudem ist die Speicherverwaltung in C++ gar kein Problem, wenn man sich darin mal ein wenig eingeübt hat. Man braucht gar nicht so viele new und delete . Die Speicherverwaltung nehmen einem oft die Container ab. Gibt sogar noch mehr nützliche Container von Boost. Ausser für wxWidgets Komponenten brauche ich kaum noch ein new, weil ich den Speicher jeweils immer gleich kapsle und per RAII oder ähnliches verwalten lasse.

Wikinger75 schrieb:

Java macht aber keine Exe^^

Kann man aber umwandeln lassen, ist aber nicht wirklich zu empfehlen. Und ein *.jar tut es oft auch. Notfalls noch eine Verknüpfung dazu und es ist kein Problem.

Wikinger75 schrieb:

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

Klar braucht man dafür .NET, welches auf fast jedem einigermasen aktuell gehaltenem Windows Rechner vorhanden sein sollte. Notfalls kann man das Zeug mitinstallieren, was eher selten ein Problem darstellt. Zumindest meistens gar keins für Privatrechner.

Mit C++ ist man oft auch von anderen Bibliotheken abhängig und statisches Linken ist nicht immer das optimalste oder zum Teil gar nicht möglich.

Grüssli

xBlackKnightx

hmmm also erst mal langsam mit boost smart pointer:

wenn ich das tippe

int main() 
{ 
shared_ptr<int> p(new int(2));
// ...
}

braucht man dann kein delete mehr.

ohne shared_ptr wäre das dann so?

int main() 
{ 
int *p = new int(2);
// ...
delete *p;
}

habe ich das so verstanden?
natürlich hab ich da was gelesen, aber es lässt sich nicht so im kopf interpretieren. man kann damit so schlecht experimentieren, weil alles hinter sichtbarem ist.