TimingTool

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.

theta

Genau. Korrekt verstanden.

man kann damit so schlecht experimentieren, weil alles hinter sichtbarem ist.

Dafür gibts "Tricks" wie z.B. bei der CRT von MS:
http://msdn.microsoft.com/en-us/library/e5ewb1h3.aspx

Simon

xBlackKnightx

okay, grad mal getestet mit

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv[])
{

	int * a = new int(2);
	// delete a;
	_CrtDumpMemoryLeaks();
	return 0;
}

funktioniert wunderbar. danke!

nur funktioniert wohl nicht wenn ich qt bibliothek benütze. naja egal...

Thomy

xBlackKnightx schrieb:

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

for( int i = 0; i < 4000000; ++i )
{
    int* a = new int[255];
}

:p

Danach funktioniert dein System nicht mehr!

Thomy schrieb:

xBlackKnightx schrieb:

es gibt noch memory leaks wenn das programm beendet wird? dachte windows räumt das automatisch auf?
for( int i = 0; i < 4000000; ++i )
{
    int* a = new int[255];
}
:p

Danach funktioniert dein System nicht mehr!

Aber nur wenn du noch mit 256KB RAM rumgurkst! Wie viel Wochen hast du denn gebraucht um die Seite anzusurfen?

Mach ne Endlosschleife drauf wenn du den Knaben crashen willst :p

Nexus

Bitte doch nicht für alles boost::shared_ptr empfehlen. boost::scoped_ptr reicht in sehr vielen Fällen, hat aber kaum Overhead.

Aber ich kann die anderen nur wiederholen: Wenn man zu faul oder unfähig ist, Speicher selbst aufzuräumen, sollte man eine andere Sprache wählen. Spätestens wenn man selbst mal speicherverwaltende Konstrukte schreibt, kommt man eh nicht mehr um eigene Implementierungen, sofern das Ganze einigermassen schlank und performant bleiben soll. Und dass man weiss, wie man delete und delete[] anwendet, gehört meiner Ansicht nach zu den Grundlagen von C++.

Hat jemand die Güte meinen Beitrag (Seite 3) zu kommentieren, ihr Haiden?

Ihr dürft den Code auch in der Luft zerfetzen!

hustbaer

Jesus Christ schrieb:

Hat jemand die Güte meinen Beitrag (Seite 3) zu kommentieren, ihr Haiden?

Ihr dürft den Code auch in der Luft zerfetzen!

Vielleicht kommentiert ihn keiner, weil er keines Kommentars würdig ist?

hustbaer schrieb:

Jesus Christ schrieb:

Hat jemand die Güte meinen Beitrag (Seite 3) zu kommentieren, ihr Haiden?

Ihr dürft den Code auch in der Luft zerfetzen!

Vielleicht kommentiert ihn keiner, weil er keines Kommentars würdig ist?

Genau setzt dich vor den Spiegel und rubbel dir einen

theta

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

Ja, stimmt, beim Process Ende wird das meiste aufgeräumt.
Trotzdem würde ich mich nicht darauf verlassen, zudem zeigt das ein sehr, sehr schlechter Stil. Du wirfst hoffentlich auch nicht immer deine Teller nach dem Essen weg und benutzt neue, anstelle sie zu waschen...

Simon