11.5. Flyweight Pattern: Implicitly Shared Classes

11.5. Flyweight Pattern: Implicitly Shared Classes
	Chapter 11. Generics and Containers

[ fromfile: refcount.xml id: refcount ]

Unlike Java, C++ has no garbage collection.
Garbage collection is a thread that recovers heap memory that is no longer referenced.
It runs when the CPU is relatively idle, or when it is running out of memory.

Reference counting is an example of resource sharing.
More efficient with CPU and developer time than Garbage Collection!

When an object is created, its reference counter is set to 1.
Each time the object is newly referenced, the reference counter is incremented.
Each time it loses a reference, the reference counter is decremented.
When the reference count becomes 0, the shared object can be deallocated.

QString and QStringList are both implemented this way
Pass by reference if you need to change the value inside

Flyweight Pattern

To avoid the need to store multiple copies of the same object, there are many situations where a lightweight wrapper can be used in place of the actual object. The wrapper class holds a pointer to shared data instead of maintaining a copy of the data. Classes that work this way implement the Flyweight Pattern, sometimes called the Bridge Pattern or the Private Implementation Pattern.

As you examine the source code of Qt, you undoubtedly notice file_p.cpp and file_p.h files that contain the implementation details of most Qt classes. This pattern helps ensure both source and binary compatibility when changing implementations of a class. In addition, it is used to achieve implicit sharing, where the data is shared across multiple implementations.

The flexibility that the Bridge Pattern gives you comes at a cost: the code is more complex (twice as many classes to manage) and you must implement a wrapper with the same interface as the original class.

To make your own implicitly shared flyweight, you can write your own reference counting code, or reuse two Qt classes: QSharedData and QSharedDataPointer.

QSharedData provides a public QAtomicInt ref member, for a reference count.
QSharedDataPointer updates the reference count of its shared data depending on whether it is being copied or detached.

Figure 11.4. Example QSharedData Private Implementation

This example starts with a relatively mundane, non-sharing MyString class that implements strings with dynamic arrays of char, shown in Example 11.15.

Example 11.15. src/mystring/shareddata/mystring.h

#ifndef MYSTRING_H
#define MYSTRING_H
#include <iostream>
class MyString {
public:
    MyString(const MyString& str); 
    MyString& operator=(const MyString& a);
    MyString(); 
    MyString(const char* chptr);  
    explicit MyString(int size);
    virtual ~MyString();
    friend std::ostream& operator<<(std::ostream& os, const MyString& s);
    int length() const;
    MyString& operator+= (const MyString& other);
    friend MyString operator+(const MyString&, const MyString&);
protected:
    int   m_Len;
    char* m_Buffer;    
    void  copy(const char* chptr);
};
#endif        //  #ifndef MYSTRING_H

Pointer to the start of dynamic array

Example 11.16 extends the MyString class by adding reference counting capability.
This is the private implementation class.

Example 11.16. src/mystring/shareddata/stringdata.h

[ . . . . ]
class StringData : public QSharedData, public MyString {
public:
    friend class SString;
    StringData() {}
    StringData(const char* d) : MyString(d) {}
    explicit StringData(int len) : MyString(len) {}
    StringData(const StringData& other) 
             : QSharedData(other), MyString(other) {}    
};
[ . . . . ]

The implicitly shared SString, shown in Example 11.17, is an example of a class that uses the QSharedDataPointer to achieve copy on write.

Example 11.17. src/mystring/shareddata/sstring.h

[ . . . . ]
class SString {
public:
    SString();
    explicit SString(int len);
    SString(const char* ptr);
    SString& operator+= (const SString& other);
    int length() const;
    int refcount() const {return m_d->ref;}
    friend SString operator+(SString, SString);
    friend std::ostream& operator<< (std::ostream&, const SString&);
[ . . . . ]
private:
    // Private Implementation Pattern
    QSharedDataPointer<StringData> m_d;
    
};
[ . . . . ]

The public methods of SString delegate to StringData.
The actual shared data is copied automatically whenever m_d is dereferenced in a non-const way.
Example 11.18 demonstrates that the refcount() decreases when one of the shared flyweights is modified.

Example 11.18. src/mystring/shareddata/sharedmain.cpp

#include <iostream>
#include "sstring.h"
using namespace std;

void passByValue(SString v) {
    cout << v << v.refcount() << endl; 
    v = "somethingelse";
    cout << v << v.refcount() << endl; 
}

int main (int argc, char* argv[]) {
    SString s = "Hello";
    passByValue(s);
    cout << s << s.refcount() << endl; 
}

	refcount=2
	refcount=1
	refcount=1

QExplicitlySharedDataPointer is the same as QSharedDataPointer, but you must explicitly call detach() on the QSharedData each time that a copy is needed.

Most Qt classes implement the Flyweight Pattern, for either implicit sharing, or for other reasons.


11.4. Function Pointers and Functors		11.6. Exercise: Generics