You need to find answer to these questions yourself by doing the back ground reading. You questions have even been answered in previous reply, you need to spend time thinking about this yourself, there are plenty of docs and discussion about ref_ptr<>. Also do experiements, put comments in the constructor/destructors. Spend the time yourself, only then will you get a real grasp of it.
Robert.
On 10/6/06, Oliver Kutter <[EMAIL PROTECTED]> wrote:
Hi Robert,
first of all, thank you for the link.
Then, I'm asking about the ref_ptr, because I have some code like the
following. I'm storing my objects in a std::list. And now I wonder if I
delete object from that list, are they really deleted?
std::list< osg::ref_ptr<Object> > myList;
Object* createObject()
{
osg::ref_ptr<Object> object = new Object();
// ------ Is the refcount increased or not?
myList.push_back (object);
// ------ I know, I shouldn't do this, but if the refcount is increased,
// ------ everything should be fine.
return object.get();
}
void deleteObject(Object* object) {
std::list< osg::ref_ptr<Object> >::iterator it;
for (it = myList.begin(); it != myList.end(); it++) {
if (it->get() == object) {
// ------ Is the refcount decreased or not?
// ------ And is the object really deleted at the end of the scope?
myList.erase(it);
}
}
}
int main ()
{
Object* myObject = createObject();
...
deleteObject(myObject);
}
regards,
Oliver
Robert Osfield schrieb:
> Hi Oliver,
>
> Please read Don's article of ref_ptr<>:
>
> http://dburns.dhs.org/OSG/Articles/RefPointers/RefPointers.html
>
> On 10/6/06, *Oliver Kutter* <[EMAIL PROTECTED]
> <mailto:[EMAIL PROTECTED]>> wrote:
>
> 1:
> osg::ref_ptr<MyClass> object1 = new MyClass();
> object1.release();
>
>
> release() releases the object and returns the pointer to it without
> decrementing the reference count. I'd recommend you own up an editor
> and walk through the code.
>
> The only time you should ever use release is when have code something like:
>
> Node* createNode()
> {
> ref_ptr<Node> node = new Node;
> return node.release();
> }
>
> As this prevents the ref_ptr<> from deleting the node object when the
> ref pointer goes out of scope.
>
> You'll see this usage pattern very occasionally in the OSG. Its not
> normal usage.
>
> In you code block you basically have a memory leak.
>
>
> 2:
> MyClass* object2 = new MyClass();
> delete object2;
>
>
> This in dangerous as you should consider what might happen if you
> addinged object2 into the scene graph - it'd take a reference to it, but
> then you've got an forceable deleted it.
>
> Reference counting is design to prevent this problem, its a very common
> tehcnique now in computing so you should be able to find plenty of
> refences on the web about it.
>
> Another trick is my you create your MyClass you shoudl make the
> destructor private/protected, this will prevent you from doing a delete
> object2 at compile time. Have a look at all the core OSG class that are
> derived from osg::Referenced, you'll find they all have protected
> destructors to prevent you from doing dangerous things like manually
> deleting them.
>
> I strongly recommend you invest some time learning about the OSG's ref
> pointers from the available docs, and also look to the web, and then
> write your own examples and play. TIme invested now will help the rest
> of your computing career.
>
> Robert.
>
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> osg-users mailing list
> [email protected]
> http://openscenegraph.net/mailman/listinfo/osg-users
> http://www.openscenegraph.org/
_______________________________________________
osg-users mailing list
[email protected]
http://openscenegraph.net/mailman/listinfo/osg-users
http://www.openscenegraph.org/
_______________________________________________ osg-users mailing list [email protected] http://openscenegraph.net/mailman/listinfo/osg-users http://www.openscenegraph.org/
