about "auto_ptr"

[greghua]

class A
{
public:
A(int a,int b):a1(a),a2(b){}
void output(){cout<<"a1="<<a1<<";a2="<<a2<<endl;}
private:
int a1;
int a2;
};

template<class T>
class auto_ptr {
public:
auto_ptr(T *p = 0): ptr(p) {}
~auto_ptr() { delete ptr;}
T* operator ->(){return ptr;}
private:
T *ptr;
};


class B
{
public:
B(int a,int b):ca(new A(a,b)){}
void output() {ca->output();}
private:
const auto_ptr<A> ca;
};

void main()
{
B b(3,4);
b.output();
}


In B, its member data is pointer which point to a class A. with the use of auto_ptr, the point will be delete automatically after object b goes out of range. my compiler doesn't support auto_ptr in standard libary, so I write it by myself.

my quest is, the program can not be compiled, but if I get of the "const" before auto_ptr<A>, it can be compiled and run right. why?

[wien]

You're calling a non-const function on a const object. That's why it fails. make the -> operator const. Also, the main function returns an int.

And please use the code tags the next time you post code.#include <iostream>
using namespace std;

class A
{
public:
A(int a,int b):a1(a),a2(b){}
void output(){cout<<"a1="<<a1<<";a2="<<a2<<endl;}
private:
int a1;
int a2;
};

template<class T>
class auto_ptr
{
public:
auto_ptr(T *p = 0): ptr(p) {}
~auto_ptr() { delete ptr;}
T* operator ->()const{return ptr;}
private:
T *ptr;
};


class B
{
public:
B(int a,int b):ca(new A(a,b)){}
void output() {ca->output();}
private:
const auto_ptr<A> ca;
};

int main()
{
B b(3,4);
b.output();
}

[Ben_Phillips]

If you write your own auto_ptr make sure that control of the pointer is transfered during assignment

Here's an example:

auto_ptr<int> a(someIntPtr);
auto_ptr<int> b;
b = a;


If both a and b point to the same variable then the variable will be "double deleted" (a's destructor will delete it and b's constructor will delete). During this sort of assignment you would want b to be the sole auto_ptr pointing to that pointer (for example set a as pointing to NULL afterwards).

Better yet just download the smart pointers from boost. They are fully implemented and can be used in containers (while auto_ptrs cannot).

http://boost.org/libs/smart_ptr/smart_ptr.htm

[greghua]

Thank you, i will tag the code next time.

You're calling a non-const function on a const object. That's why it fails. make the -> operator const. Also, the main function returns an int.

And please use the code tags the next time you post code.#include <iostream>
using namespace std;

class A
{
public:
A(int a,int b):a1(a),a2(b){}
void output(){cout<<"a1="<<a1<<";a2="<<a2<<endl;}
private:
int a1;
int a2;
};

template<class T>
class auto_ptr
{
public:
auto_ptr(T *p = 0): ptr(p) {}
~auto_ptr() { delete ptr;}
T* operator ->()const{return ptr;}
private:
T *ptr;
};


class B
{
public:
B(int a,int b):ca(new A(a,b)){}
void output() {ca->output();}
private:
const auto_ptr<A> ca;
};

int main()
{
B b(3,4);
b.output();
}

[_uj]

[ my compiler doesn't support auto_ptr in standard libary, so I write it by myself.

Implementing smart pointers is a delicate matter. Even experts fail. This is a portable standard library you can use instead,

http://www.stlport.com/

Or even better. Use the shared_ptr of Boost that has been suggested. It has a much broader usage. It can be used in STL containers for example. It's up for inclusion in the standard library.

[jolley]

and i will add in ,why not get something from the More Effective C++ by Scott Meyers in the Item 28?
regards,
jolley

[cma]

Wow, which compiler are you using that doesn't support auto_ptr? A common mistake is to forget to include the memory header file: #include <memory> which is where auto_ptr lives.

[jolley]

yeah i agree with u all ,but the auto_ptr should need something if it can run more normally.as for me, i am reading the more effective c++ now ,so Meyers mentions that the auto_ptr u list below is not so perfect as expected.so i would rather :

template<class T>
class auto_ptr
{
public:
explicit auto_ptr(T*p=0),ptr(p){}
~auto_ptr(){delete ptr;}
T*operator->()const
{
return ptr;
}


auto_ptr(auto_ptr& autoptrObject)//copy constructor
{
ptr=autoptrObject->ptr;
}
T&operator=(auto_ptr& autoptrObject) //assignment operator
{
if(this!=autoptrObject.ptr) delete ptr;
ptr=autoptrObject->ptr;
return *this;
}
T&operator*()const
{
return *ptr;
}


private:
T*ptr;
};

REgards,
jolley

[wien]

yeah i agree with u all ,but the auto_ptr should need something if it can run more normally.as for me, i am reading the more effective c++ now ,so Meyers mentions that the auto_ptr u list below is not so perfect as expected.so i would rather :
<snip>Not that I understand a word of what you are trying to get across, but:#include "jolleys_auto_ptr.h"

int main()
{
auto_ptr<int> one(new int);
auto_ptr<int> two(one);
} // Boom, you're dead!

[marten_range]

If you wish to make your own scope guard or smart pointer that is fine IMO but don't call it auto_ptr unless it correctly mimics every aspect of std::auto_ptr. It would be terribly confusing for a programmer used to std::auto_ptr.

[jolley]

yeah i agree,but i do think that the auto_ptr is appetising,i have no reason that i won't earn it.in order to put an end to the auto_ptr,and this ti me :cool: i quote from the Meyers :


template<class T>
class auto_ptr
{
explicit auto_ptr(T*p=0):pointee(p){}

template<class U>
auto_ptr(auto_ptr<U>&rhs):pointee(rhs.release()){}
~auto_ptr(){delete pointee;}

template<class U>
auto_ptr<T>& operator=(auto_ptr<U>&rhs)
{
if(this!=&rhs) reset(rhs.release());
return *this;
}

T&operator*()const{return *pointee;}
T*operator->()const{return pointee;}

T*get()const{return pointee;}
T*release()
{
T*oldPointee=pointee;
pointee=0;
return oldpointee;
}

void reset(T*p=0)
{
if(pointee!=p)
{
delete pointee;
pointee=p;
}
}

private:
T*pointee;
template<class U>friend class auto_ptr<U>;
};

guy,it is time to sleep now ,bye,bye :)

[Axter]

You might want to consider using a smart reference pointer instead.

Check out the auto_ref_ptr class in the following link:
http://code.axter.com/auto_ref_ptr.h