Smart pointers in C++

[tomy12]

Hi,

Please have a look at the code below. Is this a smart pointer?
If so, why the first object, p1, is dangling at the end of the code? (That is p2 is deleted by the destructor but p1 remains, why?

#include <iostream>
#include <vector>
using namespace std;

template <class T> class my_auto_ptr {
	T* myptr;

public:
	my_auto_ptr(T* ptr = 0) : myptr(ptr) { }

	~my_auto_ptr() {
		delete myptr;
	}

	T* operator ->() const {
		if (myptr != nullptr)  return myptr;
		else throw runtime_error("");
	}
	T& operator* () const {
		if (myptr != nullptr)  return *myptr;
		else throw runtime_error("");
	}
	T* release() {
		T* rptr = myptr;
		myptr = 0;
		return rptr;
	}
};

//----------------------------------

int main() try {
	my_auto_ptr<vector<int> > p1(new vector<int>(4, 5));
	cout << p1->size() << endl;

	my_auto_ptr<int> p2(new int(6));
	cout << *p2 << endl;
	
	return 0;
}

//-------------------------------

catch (...) {
	cerr << "Exception occurred.\n";
	return 1;
}

[2kaud]

This code calls the constructor twice and the destructor twice.

#include <iostream>
#include <vector>
using namespace std;

template <class T> 
class my_auto_ptr 
{
	T* myptr;

public:
	my_auto_ptr(T* ptr = nullptr) : myptr(ptr)
	{
		cout << "constructor" << endl;
	}

	~my_auto_ptr() {
		cout << "destructor" << endl;
		delete myptr;
	}

	T* operator ->() const {
		if (myptr != nullptr) 
			return myptr;
		else
			throw runtime_error("");
	}

	T& operator* () const {
		if (myptr != nullptr) 
			return *myptr;
		else
			throw runtime_error("");
	}

	T* release() {
		T* rptr = myptr;
		myptr = nullptr;
		return rptr;
	}
};

int main()
{
	try {
		my_auto_ptr<vector<int> > p1(new vector<int>(4, 5));
		cout << p1->size() << endl;

		my_auto_ptr<int> p2(new int(6));
		cout << *p2 << endl;

		return 0;
	}
	catch (...) {
		cerr << "Exception occurred.\n";
		return 1;
	}
}

constructor
4
constructor
6
destructor
destructor

[TubularX]

There's no dangling pointer in the example you provided.

However, my_auto_ptr is not safe to use. Think about what will happen if you make a copy.

[monarch_dodra]

auto_ptr is a dangerous concept in C++, as it can implicitly transfer ownership on copy, which is not the usually expected semantic. That is why it was removed from the standard library.

The issue is that you need to either make it non-copyable, or have the copy constructor transfer owner ship (in which case it's not really a copy).

I'd suggest you also make your constructor explicit, so as to not accidently transfer steal ownership from a pointer.

If you do want to roll out your own auto_ptr, I'd suggest you instead model after boost's scoped_ptr. It's a bit more strict, but it's much harder to mess up with it. http://www.boost.org/doc/libs/1_60_0...scoped_ptr.htm

I assume this is a learning project. Otherwise, just use std::unique_ptr and be done with it.

[ahoodin]

auto_ptr is deprecated. (as you may know unique_ptr is the better choice as of c++14).

There is no point in re-implementing a deprecated construct, even if you fixed it,
I would suggest you name it something else.

Additionally it is not a smart pointer, and it can be confused with that concept.

Another sticking point of a smart pointer is to keep a reference count, and that it has a manager object
so that if there are valid references to it, it sticks around.

I realize that your probably trying to re-invent the wheel to understand how it might work, but
in addition, your implementation should only be used by you since you have the understanding that it
should only be used as an example of the concept.

[laserlight]

Additionally it is not a smart pointer, and it can be confused with that concept.

Another sticking point of a smart pointer is to keep a reference count, and that it has a manager object
so that if there are valid references to it, it sticks around.

I disagree: reference counting is not the defining feature of a smart pointer, otherwise std::unique_ptr and boost::scoped_ptr would not be smart pointers. Rather, std::auto_ptr is a smart pointer as it is a class template that overloads operators so as to behave like a pointer, with the "smart" part coming from its usage for RAII. It just had shortcomings that made it dangerous, and obsolete with the advent of std::unique_ptr.

[ahoodin]

I disagree: reference counting is not the defining feature of a smart pointer

Oh no I did not say that it was the defining feature, just part of the functionality of the smart pointer, using a manger object to delete a pointer with no references.

[monarch_dodra]

Oh no I did not say that it was the defining feature, just part of the functionality of the smart pointer, using a manger object to delete a pointer with no references.

It is not a mandatory feature of a smart pointer. The only requirement is "lifetime management". This includes unique_ptr (which has no manager object, and does not track references), or even weak_ptr (which does track references, but does not delete the pointer).

http://en.cppreference.com/w/cpp/memory

What you are talking about is a "shared" pointer, which is a specific class of smart pointer, but far from the only kind.

[tomy12]

Thank you all very much.