Re: A Sample auto_ptr implementation

From:

Ankur Arora <ankurarora81@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 13 Oct 2008 07:10:23 -0700 (PDT)

Message-ID:

<79c9ca10-8839-47f3-903d-f22a6d30e335@y79g2000hsa.googlegroups.com>

Thanks for the reply Kai!
Please see the comments below.

On Oct 13, 2:53 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:

Ankur Arora wrote:

Hi All,

I'm building a sample application that uses a custom auto_ptr
implementation.
The program crashes with the following output:-

Output (Debug Assertion failed)
----------

         release called
         copy constructor
         aap: ptr2= 10
         aap: ptr3= 20
         aap: ptr3= 10
         aap: exiting app
         Deleting pointee...10
         Deleting pointee...-572662307 (...pr=

oblem ?)

Code
--------

Just a data point: your code works for me with output

         release called
         copy constructor
         aap: ptr2= 10
         aap: ptr3= 20
         Inside operator=
         Inside operator=, calling reset
         release called
         reset called
         aap: ptr3= 10
         aap: exiting app
         Deleting pointee...10

So I just have nits:

#include<iostream>

using namespace std;

It's a bad idea to use using namespace std in a header.

Agreed!

[snip]

template <class T>
inline MyAutoPtr<T>::~MyAutoPtr()
{
 if(pointee)
 {
 cout<<"\n\t Deleting pointee..."<<*pointee;
 delete pointee;
 }
}

delete will perform its own check for 0. It is required to be a null-op i=

that case.

I did this since removing this check caused the program to crash, even
though I had made pointee equals to 0 in release(), which was used in
the copy constructor.
I'm using visual studio 2008 express edition. You reckon this is a
complier issue?

[snip]

template<class T>
template<class U>
MyAutoPtr<T>& MyAutoPtr<T>::operator=(MyAutoPtr& rhs)
{
cout<<"\n\t Inside operator=";
if(this!=&rhs)

This if-clause will not compile when T and U are different.

You could use

if ( this->pointee == rhs.pointee )

instead (I think).

I saw this example in "More Effective C++" by scott meyers. This was
how its used in that book. Here is a code.

//Interface
template<class T>
class auto_ptr {
public:
 explicit auto_ptr(T *p = 0); // see Item 5 for a
 // description of
"explicit"
 template<class U> // copy constructor member
 auto_ptr(auto_ptr& rhs); // template (see Item 28):
 // initialize a new
auto_ptr
 // with any compatible
 // auto_ptr
 ~auto_ptr();
 template<class U> // assignment operator
 auto_ptr<T>& // member template (see
 operator=(auto_ptr& rhs); // Item 28): assign from
any
 // compatible auto_ptr
 T& operator*() const; // see Item 28
 T* operator->() const; // see Item 28
 T* get() const; // return value of current
 // dumb pointer
 T* release(); // relinquish ownership of
 // current dumb pointer
and
 // return its value
 void reset(T *p = 0); // delete owned pointer;
 // assume ownership of p
private:
 T *pointee;
template<class U> // make all auto_ptr
classes
friend class auto_ptr; // friends of one another
};

//Implementation
template<class T>
inline auto_ptr<T>::auto_ptr(T *p)
: pointee(p)
{}
template<class T>
 inline auto_ptr<T>::auto_ptr(auto_ptr& rhs)
 : pointee(rhs.release())
 {}
template<class T>
inline auto_ptr<T>::~auto_ptr()
{ delete pointee; }
template<class T>
 template<class U>
 inline auto_ptr<T>& auto_ptr<T>::operator=(auto_ptr& rhs)
 {
 if (this != &rhs) reset(rhs.release());
 return *this;
 }
template<class T>
inline T& auto_ptr<T>::operator*() const
{ return *pointee; }
template<class T>
inline T* auto_ptr<T>::operator->() const
{ return pointee; }
template<class T>
inline T* auto_ptr<T>::get() const
{ return pointee; }
template<class T>
inline T* auto_ptr<T>::release()
{
 T *oldPointee = pointee;
 pointee = 0;
 return oldPointee;
}
template<class T>
inline void auto_ptr<T>::reset(T *p)
{
 if (pointee != p) {
 delete pointee;
 pointee = p;
 }
}

Anything wrong with the above ? (would be surprised if there is, as it
came from scott meyers)

Q1. Any problems with the above code ?

It works with g++.

Again, looks like an issue with visual studio 2008 express.

Q2. What is causing operator= not to be called and how to fix it ?

A bug in your compiler?

[snip]

Best

Kai-Uwe Bux