C++Talk.NET C++ language newsgroups   Archives   FAQ   Search   Memberlist   Usergroups   Register   Profile   Log in to check your private messages   Log in  Zuweisungsoperatoren von std::auto_ptr          C++Talk.NET Forum Index -> C++ (German) View previous topic :: View next topic   Author Message Johannes Mueller Guest Posted: Thu Nov 02, 2006 9:47 pm    Post subject: Zuweisungsoperatoren von std::auto_ptr Hallo... Warum gibt es bei std::auto_ptr eigentlich keinen Zuweisungsoperator, der einen normalen Pointer zuweist? Etwa wie: std::auto_ptr<T>& operator= ( T* ); Dann könnte man statt diesem std::auto_ptr<MyType> aptr( getSomeInstanceOfMyType() ); //.. benutze aptr aptr = std::auto_ptr<MyType>( getSomeOtherInstanceOfMyType() ); dieses std::auto_ptr<MyType> aptr = getSomeInstanceOfMyType(); //.. benutze aptr aptr = getSomeOtherInstanceOfMyType(); schreiben, was ich irgendwie übersichtlicher finde. Hat doch bestimmt einen Grund, dass es den operator nicht gibt und dass der Konstruktor std::auto_ptr<T>::auto_ptr( T* ) explicit deklariert ist. Danke... joh Back to top Falk Tannhäuser Guest Posted: Fri Nov 03, 2006 12:32 am    Post subject: Re: Zuweisungsoperatoren von std::auto_ptr Johannes Mueller wrote: Quote: Warum gibt es bei std::auto_ptr eigentlich keinen Zuweisungsoperator, der einen normalen Pointer zuweist? Etwa wie: std::auto_ptr<T>& operator= ( T* ); Dann könnte man statt diesem std::auto_ptr<MyType> aptr( getSomeInstanceOfMyType() ); //.. benutze aptr aptr = std::auto_ptr<MyType>( getSomeOtherInstanceOfMyType() ); dieses std::auto_ptr<MyType> aptr = getSomeInstanceOfMyType(); //.. benutze aptr aptr = getSomeOtherInstanceOfMyType(); schreiben, was ich irgendwie übersichtlicher finde. Du kannst einfach aptr.reset(getSomeOtherInstanceOfMyType()); schreiben. Quote: Hat doch bestimmt einen Grund, dass es den operator nicht gibt und dass der Konstruktor std::auto_ptr<T>::auto_ptr( T* ) explicit deklariert ist. Ein implizit verwendbarer Konstruktor wäre zu gefährlich: void foo(std::auto_ptr<int>); .... int* p = new int(42); foo(p); // Angenommen, es ginge... *p = 666; // Aua! 'p' zeigt hier schon ins Nirwana... Auch ein Zuweisungsoperator würde es einem flüchtigen Leser nicht unbedingt ins Auge springen lassen, dass mit der Zuweisung die "Eigentümerschaft" (d.h. die Verantwortung für das 'delete') übernommen wird - da ist die 'reset()'-Funktion klarer. MfG Falk Back to top albrecht.fritzsche Guest Posted: Fri Nov 03, 2006 12:39 am    Post subject: Re: Zuweisungsoperatoren von std::auto_ptr Johannes Mueller wrote: Quote: Warum gibt es bei std::auto_ptr eigentlich keinen Zuweisungsoperator, der einen normalen Pointer zuweist? Etwa wie: std::auto_ptr<T>& operator= ( T* ); Dann könnte man statt diesem std::auto_ptr<MyType> aptr( getSomeInstanceOfMyType() ); //.. benutze aptr aptr = std::auto_ptr<MyType>( getSomeOtherInstanceOfMyType() ); dieses std::auto_ptr<MyType> aptr = getSomeInstanceOfMyType(); //.. benutze aptr aptr = getSomeOtherInstanceOfMyType(); schreiben, was ich irgendwie übersichtlicher finde. Du hast zwei Alternativen - die klarere ist mE die Verwendung von auto_ptr<MyType> als Rückgabewert Deiner Funktion. Dann kannst Du zum einen es genau so schreiben, wie Du eigentlich willst. Zum anderen macht das Interface von getSomeOtherInstanceOfMyType() klar, dass da intern Speicher allokiert wurde, den der Client freigeben soll. auto_ptr<MyType> source(); macht dies viel klarer als MyType* source(); Die zweite Alternative is die Memberfkt auto_ptr<>::reset(). Quote: Hat doch bestimmt einen Grund, dass es den operator nicht gibt und dass der Konstruktor std::auto_ptr<T>::auto_ptr( T* ) explicit deklariert ist. Das der Konstruktor explicit ist, hat den gleichen Grund wie auch bei anderen Klassen - die implizite Konvertierung in einen auto_ptr<> soll vermieden werden. Ansonsten wuerde ja void check(auto_ptr<T> p) { ... } T t; check(&t); seltsame Dinge veranstalten. Ali Back to top Marcel Müller Guest Posted: Fri Nov 03, 2006 2:26 am    Post subject: Re: Zuweisungsoperatoren von std::auto_ptr Hallo, Johannes Mueller wrote: Quote: Hat doch bestimmt einen Grund, dass es den operator nicht gibt und dass der Konstruktor std::auto_ptr<T>::auto_ptr( T* ) explicit deklariert ist. die Fehleranfälligkeit der Syntax ist wohl der Grund. Gar zu leicht hat man ein Pointer-Objekt sonst in einen auto_ptr geschafft, ohne es zu wollen. Und dann gibt es undefiniertes Verhalten, weil irgendetwas freigegeben wird, was nie hätte freigegeben werden sollen. Ein bisserl schöner als im genannten Beispiel geht es aber dann doch: std::auto_ptr<MyType> aptr( getSomeInstanceOfMyType() ); //.. benutze aptr aptr.reset( getSomeOtherInstanceOfMyType() ); Aber wem das nicht gefällt, der mag einfach von auto_ptr erben und die gewünschten Operatoren implementieren. Wenn man die Sache mit den Konstruktoren richtig macht, ist die Klasse sogar interoperabel mit std::auto_ptr. Ich weiß allerdings nicht sicher, inwieweit der erforderliche Hack mit struct auto_ptr_ref Teil des Standards ist oder ob es der Implementation freigestellt ist, das Teil zu benennen. Marcel Back to top Johannes Mueller Guest Posted: Mon Nov 06, 2006 2:59 am    Post subject: const correctness von std::auto_ptr<T>::operator->() (was: R albrecht.fritzsche <albrecht.fritzsche (AT) arcor (DOT) de> skribis: Quote: Johannes Mueller wrote: Warum gibt es bei std::auto_ptr eigentlich keinen Zuweisungsoperator, der einen normalen Pointer zuweist? Etwa wie: [...] Quote: Du hast zwei Alternativen - die klarere ist mE die Verwendung von auto_ptr<MyType> als Rückgabewert Deiner Funktion. Dann kannst Du zum einen es genau so schreiben, wie Du eigentlich willst. Zum anderen macht das Interface von getSomeOtherInstanceOfMyType() klar, dass da intern Speicher allokiert wurde, den der Client freigeben soll. auto_ptr<MyType> source(); macht dies viel klarer als MyType* source(); Ja, das ist eine Idee. Quote: Die zweite Alternative is die Memberfkt auto_ptr<>::reset(). Hat doch bestimmt einen Grund, dass es den operator nicht gibt und dass der Konstruktor std::auto_ptr<T>::auto_ptr( T* ) explicit deklariert ist. Das hatte ich übersehen in der man-page. Quote: Das der Konstruktor explicit ist, hat den gleichen Grund wie auch bei anderen Klassen - die implizite Konvertierung in einen auto_ptr<> soll vermieden werden. Ansonsten wuerde ja void check(auto_ptr<T> p) { ... } T t; check(&t); seltsame Dinge veranstalten. Einsichtig ja. Jetzt habe ich noch eine Frage zu der const correctness von den Zugriffsoperatoren. Es gibt da beispielsweise: T* std::auto_ptr<T>::operator->() const Der ist als const deklariert, gibt aber einen pointer-to-nonconst zurück. Dadurch verhält sich const std::auto_ptr<T> anders als const T*. Beispiel: class MyClass { //... public: void nonConstMethod(); // nicht const //... }; Und später: MyClass* mc = ... const MyClass* normalConst = mc; const std::auto_ptr<MyClass> autoConst( mc ); normalConst->nonConstantMethod(); // kompiliert nicht. autoConst->nonConstantMethod(); // kompiliert, obwohl autoConst // const ist. Dem könnte man abhelfen durch einfaches const overloading [1] des operator->(). Warum wird das nicht so gemacht? Was ist der tiefere Sinn dahinter? Es entsteht doch so eine gewisse Inkonsistenz. Danke joh __________________________ [1] http://www.parashift.com/c++-faq-lite/const-correctness.html#faq-18.12 Back to top Rolf Magnus Guest Posted: Mon Nov 06, 2006 5:14 am    Post subject: Re: const correctness von std::auto_ptr<T>::operator->() (wa Johannes Mueller wrote: Quote: Jetzt habe ich noch eine Frage zu der const correctness von den Zugriffsoperatoren. Es gibt da beispielsweise: T* std::auto_ptr<T>::operator->() const Der ist als const deklariert, gibt aber einen pointer-to-nonconst zurück. Dadurch verhält sich const std::auto_ptr<T> anders als const T*. Ein const std::auto_ptr<T> wäre auch nicht zu const T*, sondern zu T* const äquivalent. Ersterer wäre ein nichtkonstanter Zeiger auf ein const T, zweiter ein konstanter Zeiger auf ein T. Umgekehrt wäre das Pendant zu einem const T* ein std::auto_ptr<const T>. Quote: Beispiel: class MyClass { //... public: void nonConstMethod(); // nicht const //... }; Und später: MyClass* mc = ... const MyClass* normalConst = mc; const std::auto_ptr<MyClass> autoConst( mc ); Dreh's mal um: MyClass* const normalConst = mc; std::auto_ptr<MyClass> const autoConst( mc ); Quote: normalConst->nonConstantMethod(); // kompiliert nicht. autoConst->nonConstantMethod(); // kompiliert, obwohl autoConst // const ist. Dem könnte man abhelfen durch einfaches const overloading [1] des operator->(). Warum wird das nicht so gemacht? Weil die "Konstantheit" des Zeigers nichts mit der des Objekts zu tun hat, auf das er zeigt. Back to top Markus Moll Guest Posted: Mon Nov 06, 2006 6:15 am    Post subject: Re: const correctness von std::auto_ptr<T>::operator->() (wa Hallo Johannes Mueller wrote: Quote: Jetzt habe ich noch eine Frage zu der const correctness von den Zugriffsoperatoren. Es gibt da beispielsweise: T* std::auto_ptr<T>::operator->() const Der ist als const deklariert, gibt aber einen pointer-to-nonconst zurück. Dadurch verhält sich const std::auto_ptr<T> anders als const T*. Wenn überhaupt sollte er sich aber auch eher wie ein T * const verhalten. Schließlich ist es ein konstanter Zeiger. Und das tut er durchaus. Man kann einem konstanten auto_ptr keinen anderen Wert zuweisen. Aufgrund seiner Natur kann ein solcher auto_ptr aber zusätzlich auch nicht für Zuweisung an einen oder Initialisierung eines zweiten auto_ptr benutzt werden. Insofern sehe ich auch keine Inkonsistenz. Gruß Markus Back to top Jörg Barfurth Guest Posted: Mon Nov 06, 2006 6:18 am    Post subject: Re: const correctness von std::auto_ptr<T>::operator->() Hallo Johannes, Johannes Mueller schrieb: Quote: Jetzt habe ich noch eine Frage zu der const correctness von den Zugriffsoperatoren. Es gibt da beispielsweise: T* std::auto_ptr<T>::operator->() const Der ist als const deklariert, gibt aber einen pointer-to-nonconst zurück. Dadurch verhält sich const std::auto_ptr<T> anders als const T*. Das sind auch zwei verschiedene Dinge: Das erste ist ein konstatnter (Auto-)Pointer auf ein nichtkonstantes T (<T>). Das andere ist ein nichtkonstanter Pointer auf ein konstantes T. Manche Leute schreiben const stets auf der rechten Seite - das vermeidet solche Verwirrung: auto_ptr<T> const verhält sich genau wie T * const oder typedef T * TPtr; TPtr const ... Und ein T const * (das ist dasselbe wie 'const T *') entspricht einem auto_ptr<const T> Quote: Dem könnte man abhelfen durch einfaches const overloading [1] des operator->(). Warum wird das nicht so gemacht? Was ist der tiefere Sinn dahinter? Es entsteht doch so eine gewisse Inkonsistenz. Nein, nur so ist es konsistent. Wenn der Pointer unveränderlich ist, kann man durch ihn trotzdem auf ein veränderliches Objekt zugreifen. - Jörg Back to top Display posts from previous: All Posts1 Day7 Days2 Weeks1 Month3 Months6 Months1 Year Oldest FirstNewest First         C++Talk.NET Forum Index -> C++ (German) All times are GMT Page 1 of 1   Jump to: Select a forum C/C++----------------C LanguageC Language (Moderated)C++ Language (Moderated)C++ language (comp.lang.c++)C++ language, library and standards Non-English C/C++ Newsgroups----------------C++ (German)C++ (French)  You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum Powered by phpBB © 2001, 2006 phpBB Group SEO toolkit © 2004-2006 webmedic.