auto_ptr vs. boost::shared_ptr

hi
was is der unterschied zwischen beiden methoden da? sollte das nicht das gleiche machen...also wenn man ein objekt am heap anlegt dann gibt die methode die die instanz per pointer zurück? und auoto_ptr bzw der smart pointer löschen halt nur die instanzen dann automatisch?

cu

std::auto_ptr<Socket> accept() const
{
	assert(isValid());

	listen();

	SOCKET socket = ::accept(socket_, NULL, NULL);

	if(socket == INVALID_SOCKET)
	{
		THROW_SOCKET_EXCEPTION("::accept failed!");
	}

	return std::auto_ptr<Socket>(new Socket(socket));
}

boost::shared_ptr<Socket> accept const
{
        assert(isValid());

	listen();

	SOCKET socket = ::accept(socket_, NULL, NULL);

	if(socket == INVALID_SOCKET)
	{
		THROW_SOCKET_EXCEPTION("::accept failed!");
	}

        return boost::shared_ptr<Socket>(new Socket));
}

volkard

shared_ptr kann mehr als auto_ptr. shared_ptr ist so ein rightig guter smart pointer, der auch mach, was man von ihm erwartet. auto_ptr verfolgt ein fieses konzept, das nich total leicht zu kapieren ist und das zum beispiel die verwendung in containern verbietet. aber schneller ist auto_ptr. hier reicht auto_ptr. aber ich nehme an, speed juckt dich nicht die bohne, dann ist es besserm du verwendest durchgängig shared_ptr. da brennt nix an dabei.

otze

shared pointer würde ich nur dann verwenden, wenn ich wirklich mehr als einen zeiger auf ein heap objekt brauche, ansonsten nutz ich lieber auto_ptr

hi!
return std::auto_ptr<Socket>(new Socket(socket));

gibt mir ja einen zeiger zurück auf das neu erstellte objekt am heap? ändert sich was wenn ich da das mit ner referenz zurück gebe? ich will das objekt hat nicht kopieren...

cu

Gerard

ja der funktionsaufrufer muss den speicher irgend wie freigeben

Socket & r = obj.accept();
//...
delete &r;

das ganze entspricht nicht das was man erwartet,

ein auto_ptr arbeitet nach dem prinzip von copied-object pointer?
...Ein auto_ptr besitzt das Objekt, das er verwaltet...das auto_ptr object wird also auf dem stack angelegt...

was passiert beim beim Kopieren eines auto_ptr-Objekts?

auto_ptr <foo> object1 (new foo);
auto_ptr <foo> object2;
object2 = object1;

wird dann das object object1 ungültig? und object2 übernimmt den besitz von object1...also hat nun X?
was ist wenn object2 bereits ein object hat?

wobei ein boost::smart_ptr nach dem prinzip von reference-counted-object pointer arbeitet?
Hier dürfen mehrere Pointer auf dasselbe Objekt zeigen
Bei Kopieren des Pointers wird nicht das Objekt kopiert, sondern nur der Zähler wird erhöht...

Es sollen natürlich auch Zuweisungen von normalen Pointern an Smart Pointer möglich sein, wie?

situation:

boost::shared_ptr<Object> a (new Object);
boost::shared_ptr<Object> b = a; // hier wird pointer übertragen, refcount erhöht
a = b; // hier sollte nix passieren, da beide auf dasselbe objekt zeigen??

situation:

foo *ptr1 = new foo;
boost::shared_ptr <foo> object1 (ptr1), object2(ptr1); // 2 shared_ptr zeigen auf dasselbe object..
foo *ptr2 = new foo;
ptr1 = ptr2;  // zeigen hier dann 2 smart pointer auf 2 objecte?
// der reference counter ist dann 2 mal auf 1?

cu

evilissimo

Hat sich erledigt.