Smart Pointers
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share

Smart Pointers

  • 9,533 views
Uploaded on

Smart pointers are similar to regular pointers, but take care of the details of deleting the object being pointed to when it is no longer needed.

Smart pointers are similar to regular pointers, but take care of the details of deleting the object being pointed to when it is no longer needed.

More in: Technology , Education
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
9,533
On Slideshare
9,154
From Embeds
379
Number of Embeds
10

Actions

Shares
Downloads
200
Comments
0
Likes
3

Embeds 379

http://okolovich.info 331
http://www.slideshare.net 23
http://www.linkedin.com 8
http://sraap285 8
http://localhost 2
http://blog.naver.com 2
http://webcache.googleusercontent.com 2
https://si0.twimg.com 1
url_unknown 1
https://twimg0-a.akamaihd.net 1

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Qt Smart Pointers By Roman Okolovich
  • 2. Overview  Memory management in C++ is left up to the programmer.  Smart pointers are the preferred way in C++ to ensure correct management of dynamic memory allocated by new expressions.  Smart pointers are similar to regular pointers, but take care of the details of deleting the object being pointed to when it is no longer needed.  The C++ Standard Library already contains std::auto_ptr, a smart pointer with transfer-of- ownership semantics.  New C++ Standard may be issued by the end of 2010 and it will introduce new smart pointers. 2 7 February 2010
  • 3. General  Shared pointer versus shared data  When you share pointers, the value of the pointer and its lifetime is protected by the smart pointer class but the object that the pointer is pointing to is completely outside its control.  Sharing of data involves the smart pointer class knowing something about the data being shared (Implicitly Shared Qt Classes).  Strong versus weak pointer  Strong pointers own the object they point to. Multiple strong pointers can share ownership. An object is guaranteed to stay alive as long as at least one strong pointer still points to it.  Weak pointers observe an object. They can be used exactly like strong pointers, but they do not keep their object alive. If an object is destructed, all of its weak pointers will be valued null. 3 7 February 2010
  • 4. C++0x smart pointers  std::shared_ptr<>  The shared_ptr is a reference-counted pointer that acts as much as possible like a regular C++ data pointer. The shared pointer will automatically destroy its contents only when there are no shared pointers referencing the object originally created for the shared pointer.  std::weak_ptr<>  A weak_ptr is a reference to an object referenced by a shared_ptr that can determine if that object has been deleted or not. weak_ptr itself cannot be dereferenced; accessing the actual pointer requires the creation of a shared_ptr object.  std::unique_ptr<>  unique_ptr will be provided as a replacement for auto_ptr which will be deprecated. It provides all the features of auto_ptr with the exception of unsafe implicit moving from lvalues. Unlike auto_ptr, unique_ptr can be used with the C++0x move-aware containers.  Currently GCC since 4.3 and MSVC 2010 support C++0x 4 7 February 2010
  • 5. Qt smart pointers  QPointer (4.0)  QSharedDataPointer (4.0)  QExplicitlySharedDataPointer (4.4)  QSharedPointer (4.5)  QWeakPointer (4.5)  QScopedPointer (4.6)  Internal  QtPatternist::AutoPtr (internal class, 4.4)  QGuard (internal class, 4.6) 5 7 February 2010
  • 6. QPointer  QPointer is a weak pointer class and it shares the pointer value, not the data.  It only operates on QObject and QObject-derived classes.  QPointer has one serious flaw: it lets you know whether the object has been deleted, but it makes no guarantee about the next line! For example, the following code could be in trouble: QPointer<QObject> o = getObject(); // […] if (!o.isNull()) o->setProperty(“objectName”, “Object”);  Even if isNull() returns false, there’s no guarantee that the object won’t get deleted by the next line.  Therefore, QPointer can only be used to access the object if you can guarantee, by external means, that the object won’t get deleted. For example, QWidget and its descendents can only be created, manipulated and deleted in the GUI thread. If your code is running on the GUI thread or has that thread blocked, then QPointer usage is safe. 6 7 February 2010
  • 7. QSharedDataPointer  The most important of the smart pointer classes in Qt.  It provides implicit sharing, with thread-safe copy-on-write.  The QSharedData class is used as a base class for shared data objects.  QSharedDataPointer requires that the class have a member called ref (see QAtomicInt member in QSharedData class)  The member offers a function called ref() for increasing the reference count and another called deref() that decreases that reference count and returns false when it drops to zero.  QSharedDataPointer members: inline void detach() {if (d && d->ref != 1) detach_helper();} inline T * operator->() {detach(); return d; } inline const T *operator->() const { return d; } private: T *d;  Any non-const access will cause the data to be copied.  The size of a QSharedDataPointer object is exactly the size of a pointer  That means it’s possible to replace normal pointers with it in the code without breaking Binary Compatibility.  This class is the basis of all Qt value-type, implicit-shared, thread-safe copy-on-write recent classes.  The only reason why it isn’t used in the base classes like QByteArray, QString and QList is that those classes were developed before this class was made.  So QSharedDataPointer is a strong smart pointer class, sharing data. 7 7 February 2010
  • 8. QExplicitlySharedDataPointer  The QExplicitlySharedDataPointer class represents a pointer to an explicitly shared object.  This class is exactly like QSharedDataPointer (so it’s a strong smart pointer class, sharing data), with the only difference that it do not do the automatic copy on write operation (detach()) that non-const members of QSharedDataPointer do before allowing the shared data object to be modified.  There is a detach() function available, but if you really want to detach(), you have to call it yourself. This means that QExplicitlySharedDataPointers behave like regular C++ pointers, except that by doing reference counting and not deleting the shared data object until the reference count is 0, they avoid the dangling pointer problem.  QExplicitlySharedDataPointer members: inline void detach() {if (d && d->ref != 1) detach_helper();} inline T *operator->() { return d; } inline const T *operator->() const { return d; } 8 7 February 2010
  • 9. QSharedDataPointer versus QExplicitlySharedDataPointer class EmployeeData : public QSharedData // can be defined in a separate file { public: EmployeeData() : id(-1) { name.clear(); } EmployeeData(const EmployeeData &other) : QSharedData(other), id(other.id), name(other.name) { } ~EmployeeData() {} int id; QString name; }; //------ the public file ------------------------------------------------------ class EmployeeData; // predeclare the private subclass class Employee { public: Employee() { d = new EmployeeData; } Employee(int id, QString name) {d = new EmployeeData(); setId(id); setName(name);} Employee(const Employee &other) : d (other.d) {} void setId(int id) { d->id = id; } void setName(QString name) { d->name = name; } int id() const { return d->id; } QString name() const { return d->name; } private: // a copy constructor or an assignment operator are not needed QSharedDataPointer<EmployeeData> d; }; int main(int argc, char *argv[]) { Employee e1(1001, "Albrecht Durer"); Employee e2 = e1; int i = e2.id(); e1.setName("Hans Holbein"); // a copy on write is performed for QSharedDataPointer } 9 7 February 2010
  • 10. QSharedPointer  The QSharedPointer class holds a strong reference to a shared pointer.  The QSharedPointer is an automatic, shared pointer in C++. It behaves exactly like a normal pointer for normal purposes, including respect for constness.  it is polymorphic, it supports static, const, and dynamic casts, it implements atomic reference-counting and thread-safe semantics (it’s only for the pointer itself: remember it shares the pointer, not the data), it supports custom deleters.  QSharedPointer will delete the pointer it is holding when it goes out of scope, provided no other QSharedPointer objects are referencing it.  A QSharedPointer object can be created from a normal pointer, another QSharedPointer object or by promoting a QWeakPointer object to a strong reference.  It comes with a cost, though: to support polymorphism correctly, the size of QSharedPointer is actually twice the size of a normal pointer. This means you cannot maintain binary compatibility while replacing a normal pointer with it in public parts of your API. You can use it internally in your code, though. 10 7 February 2010
  • 11. QWeakPointer  The QWeakPointer class holds a weak reference to a shared pointer.  The QWeakPointer is an automatic weak reference to a pointer in C++. It cannot be used to dereference the pointer directly, but it can be used to verify if the pointer has been deleted or not in another context.  QWeakPointer objects can only be created by assignment from a QSharedPointer and they let you know when a QSharedPointer has been deleted. QWeakPointer<Data> weak(getSharedPointer()); QSharedPointer<Data> ptr = weak.toStrongRef(); if ( !ptr.isNull() ) ptr->doSomething();  In this case, the promotion of a QWeakPointer to a QSharedPointer will either succeed or it won’t. But that’s a thread- safe decision.  QWeakPointer can be used to track deletion classes derives from QObject. It is more efficient than QPointer, so it should be preferred in all new code. 11 7 February 2010
  • 12. QScopedPointer  The QScopedPointer class stores a pointer to a dynamically allocated object, and deletes it upon destruction.  It provides a very nice way to do RAII (Resource Acquisition Is Initialization).  It implements a non-shared strong pointer wrapper.  QScopedPointer guarantees that the object pointed to will get deleted when the current scope disappears.  It intentionally has no copy constructor or assignment operator, such that ownership and lifetime is clearly communicated. void myFunction(bool useSubClass) { // assuming that MyClass has a virtual destructor QScopedPointer<MyClass> p(useSubClass ? new MyClass() : new MySubClass); QScopedPointer<QIODevice> device(handsOverOwnership()); if (m_value > 3) return; process(device); }  QSharedPointer has the size of two pointers.  It also has a custom deleter as a template parameter, as opposed to a parameter to the constructor (like QSharedPointer does): it has no space in those 4 or 8 bytes to store the custom deleter.  QScopedPointer and QExplicitlySharedDataPointer are already used all over the place in the Qt for S60. 12 7 February 2010
  • 13. References  Pointer (computing)  Smart pointer  C++0x  Introducing QScopedPointer  Count with me: how many smart pointer classes does Qt have? 13 7 February 2010