Boost libraries

[wysota]

Smart pointers delete objects? I think we're having a different concept of smart pointers... Mine is that it sets the pointer to 0 once the object pointed is deleted. The concept you described I'd call a hijacking pointer and I don't want my pointers hijacked Anyway: QPointer.

[steg90]

Hi,

Not heard of 'hijacking' pointer

I'll take a look at QPointer, thanks!

Regards,
Steve

[wysota]

It's hijacking, because when it's destroyed, it destroys the pointed object as well (that's what you said). This means that if it doesn't have ownership of the object, it'll hijack it from the real owner. And it's probably implemented more or less like so:

template <typename T> class HijackingPointer {
public:
  HijackingPointer(T *ptr=0), m_ptr(ptr){}
  void setPointer(T* ptr){ m_ptr = ptr; }
  ~HijackingPointer(){ delete m_ptr; }
  // + operator T*, operator * and operator ->
private:
  T* m_ptr;
};

template <typename T> class HijackingPointer {
public:
  HijackingPointer(T *ptr=0), m_ptr(ptr){}
  void setPointer(T* ptr){ m_ptr = ptr; }
  ~HijackingPointer(){ delete m_ptr; }
  // + operator T*, operator * and operator ->
private:
  T* m_ptr;
};

To copy to clipboard, switch view to plain text mode 

I don't think I have to link to a bloated library just for this small snippet.

[jacek]

I don't think I have to link to a bloated library just for this small snippet.

std::auto_ptr from STL is the one that "hijacks" pointers, not the classes from Boost's Smart Pointers family.

[wysota]

So Boost pointers won't do that for you:

. I have 'played' with it in the past and used mainly the smart pointers as I often forget to delete pointers and using these, it does it for you.

Right?

[jacek]

So Boost pointers won't do that for you: [...] Right?

It depends which one you choose.

[wysota]

So is there a pointer in the family that deletes objects pointed to when it's deleted but doesn't hijack the object (for me this is contradictory, but maybe I just can't imagine the situation)?

[jacek]

So is there a pointer in the family that deletes objects pointed to when it's deleted but doesn't hijack the object (for me this is contradictory, but maybe I just can't imagine the situation)?

Boost has three kinds of smart pointers:

• shared pointers, which share the ownership amongs them,
• scoped pointers, which take the ownership for themselves,
• weak pointers, which don't take the ownership, but know when the object was destroyed.

All these three kinds of smart pointers are well behaved and the term "hijacking" isn't appropriate. It's just as if you said that QCoreApplication::postEvent() "hijacks" pointers, because it takes their ownership --- it doesn't, it's just a part of its contract.

If you want to call something "pointer hijacking", take a look what std::auto_ptrs do on copy --- they're like hungry hienas, which steal a dead antilope from each other.

[wysota]

So "weak pointer" is an equivalent of QPointer, "scoped pointer" does to pointers more or less what QMutexLocker does to mutexes and shared pointer is a combination of the two that does reference counting. Correct? Of course all these might fail if you use any regular pointers with the same object.

[jacek]

Correct?

Yes.

Of course all these might fail if you use any regular pointers with the same object.

Like everything which deals with pointers.

[wysota]

Like everything which deals with pointers.

But not QPointer

[Michiel]

But not QPointer

It's nothing to boast about if your smart pointer is restricted to QObject descendants.