Archive for the ‘GotW’ Category
Following on from #95, let’s consider reasons and methods to avoid mutable sharing in the first place…
Consider the following code from GotW #95’s solution, where some_obj is a shared variable visible to multiple threads which then synchronize access to it.
// thread 1{
lock_guard hold(mut_some_obj);
// acquire lock
code_that_reads_from( some_obj );
// passes some_obj by const &}// thread 2{
lock_guard hold(mut_some_obj);
// acquire lock
code_that_modifies( some_obj );
// passes some_obj by non-const &}
JG Questions
1. Why do mutable shared variables like some_obj make your code:
(a) more complex?
(b) more brittle?
(c) less scalable?
Guru Questions
2. Give an example of how the code that uses a mutable shared variable like some_obj can be changed so that the variable is:
(a) not shared.
(b) not mutable.
3. Let’s say we’re in a situation where we can’t apply the techniques from the answers to #2, so that the variable itself must remain shared and apparently mutable. Is there any way that the internal implementation of the variable can make the variable be physically not shared and/or not mutable, so that the calling code can treat it as a logically shared-and-mutable object yet not need to perform external synchronization? If so, explain. If not, why not?
This GotW was written to answer a set of related frequently asked questions. So here’s a mini-FAQ on “thread safety and synchronization in a nutshell,” and the points we’ll cover apply to thread safety and synchronization in pretty much any mainstream language.
JG Questions
1. What is a race condition, and how serious is it?
2. What is a correctly synchronized program? How do you achieve it? Be specific.
Guru Questions
3. Consider the following code, where some_obj is a shared variable visible to multiple threads.
// thread 1 (performs no additional synchronization)code_that_reads_from( some_obj );
// passes some_obj by const &// thread 2 (performs no additional synchronization)code_that_modifies( some_obj );
// passes some_obj by non-const &
If threads 1 and 2 can run concurrently, is this code correctly synchronized if the type of some_obj is:
(b) string?
(c) vector&map&int,string&&?
(d) shared_ptr&widget&?
(e) mutex?
(f) condition_variable?
(g) atomic&unsigned&?
Hint: This is actually a two-part question, not a seven-part question. There are only two unique answers, each of which covers a subset of the cases.
4. External synchronization means that the code that uses/owns a given shared object is responsible for performing synchronization on that object. Answer the following questions related to external synchronization:
(a) What is the normal external synchronization responsibility of code that owns and uses a given shared variable?
(b) What is the “basic thread safety guarantee” that all types must obey to enable calling code to perform normal external synchronization?
(c) What partial internal synchronization can still be required within the shared variable’s implementation?
5. Full internal synchronization (a.k.a. “synchronized types” or “thread-safe types”) means that a shared object performs all necessary synchronization internally within that object, so that calling code does not need to perform any external synchronization. What types should be fully internally synchronized, and why?
The discussion in this GotW applies not only to C++ but also to any mainstream language, except mainly that certain races have defined behavior in C# and Java. But the definition of what variables need to be synchronized, the tools we use to synchronize them, and the distinction between external and internal synchronization and when you use each one, are the same in all mainstream languages. If you’re a C# or Java programmer, everything here applies equally to you, with some minor renaming such as to rename C++ atomic to C#/Java volatile, although some concepts are harder to express in C#/Java (such as identifying the read-only methods on an otherwise m there are readonly fields and “read-only” properties that have get but not set, but they express a subset of what you can express using C++ const on member functions).
Note: C++ volatile variables (which have no analog in languages like C# and Java) are always beyond the scope of this and any other article about the memory model and synchronization. That’s because C++ volatile variables aren’t about threads or communication at all and don’t interact with those things. Rather, a C++ volatile variable should be viewed as portal into a different universe beyond the language — a memory location that by definition does not obey the language’s memory model because that memory location is accessed by hardware (e.g., written to by a daughter card), have more than one address, or is otherwise “strange” and beyond the language. So C++ volatile variables are universally an exception to every guideline about synchronization because are always inherently “racy” and unsynchronizable using the normal tools
(mutexes, atomics, etc.) and more generally exist outside all normal of the language and compiler including that they generally cannot be optimized by the compiler (because the compiler isn’t allowed to
may not behave anything like a normal int, and you can’t even assume that code like vi = 5; int read_back = is guaranteed to result in read_back == 5, or that code like int i = int j = that reads vi twice will result in i == j which will not be true if vi is a hardware counter for example). For more discussion, see my article
1. What is a race condition, and how serious is it?
A race condition occurs when two threads access the same shared variable concurrently, and at least one is a non-const operation (writer). Concurrent const operations are valid, and do not race with each other.
Consecutive nonzero-length bitfields count as a single variable for the purpose of defining what a race condition is.
Terminology note: Some people use “race” in a different sense, where in a program with no actual race conditions (as defined above) still operations on different threads could interleave in different orders in different executions of a correctly-synchronized program depending on how fast threads happen to execute relative to each other. That’s not a race condition in the sense we mean here—a better term for that might be “timing-dependent code.”
If a race condition occurs, your program has undefined behavior. C++ does not recognize any so-called “benign races”—and in languages that have recognized some races as “benign” the community has gradually learned over time that many of them actually, well, aren’t.
Guideline: Reads (const operations) on a shared object are safe to run concurrently with each other without synchronization.
2. What is a correctly synchronized program? How do you achieve it? Be specific.
A correctly synchronized program is one that contains no race conditions. You achieve it by making sure that, for every shared variable, every thread that performs a write (non-const operation) on that variable is synchronized so that no other reads or writes of that variable on other threads can run concurrently with that write.
The shared variable usually protected by:
(commonly) using a mutex
(very rarely) by making it atomic if that’s appropriate, such as in low- or
(very rarely) for certain types by performing the synchronization internally, as we will see below.
3. Consider the following code… If threads 1 and 2 can run concurrently, is this code correctly synchronized if the type of some_obj is: (a) int? (b) string? (c) vector&map&int,string&&? (d) shared_ptr&widget&?
No. The code has one thread reading (via const operations) from some_obj, and a second thread writing to the same variable. If those threads can execute at the same time, that’s a race and a direct non-stop ticket to undefined behavior land.
The answer is to synchronize access to the variable, for example using a mutex:
// thread 1{
lock_guard hold(mut_some_obj);
// acquire lock
code_that_reads_from( some_obj );
// passes some_obj by const &}// thread 2{
lock_guard hold(mut_some_obj);
// acquire lock
code_that_modifies( some_obj );
// passes some_obj by non-const &}
Virtually all types, including shared_ptr and vector and other types, are just as thread-safe as int; they’re not special for concurrency purposes. It doesn’t matter whether some_obj is an int, a string, a container, or a smart pointer… concurrent reads (const operations) are safe without synchronization, but the shared object is writeable, then the code that owns the object has to synchronize access to it.
But when I said this is true for “virtually all types,” I meant all types except for types that are not fully internally synchronized, which brings us to the types that, by design, are special for concurrency purposes…
… If threads 1 and 2 can run concurrently, is this code correctly synchronized if the type of g+shared is: (e) mutex? (f) condition_variable? (g) atomic&unsigned&?
Yes. For these types, the code is okay, because these types already perform full internal synchronization and so they are safe to access without external synchronization.
In fact, these types had better be safe to use without external synchronization, because they’re synchronization primitives you need to use as tools to synchronize other variables! And its turns out that that’s no accident…
Guideline: A type should only be fully internally synchronized if and only if its purpose is to provide
inter-thread communication (e.g., a message queue) or synchronization (e.g., a mutex).
4. External synchronization means that the code that uses/owns a given shared object is responsible for performing synchronization on that object. Answer the following questions related to external synchronization:
(a) What is the normal external synchronization responsibility of code that owns and uses a given shared variable?
The normal synchronization duty of care is simply this: The code that knows about and owns a writeable shared variable has to synchronize access to it. It will typically do that using a mutex or similar (~99.9% of the time), or by making it atomic if that’s possible and appropriate (~0.1% of the time).
Guideline: The code that knows about and owns a writeable shared variable is responsible for synchronizing access to it.
(b) What is the “basic thread safety guarantee” that all types must obey to enable calling code to perform normal external synchronization?
To make it possible for the code that uses a shared variable to do the above, two basic things must be true.
First, concurrent operations on different objects must be safe. For example, let’s say we have two X objects x1 and x2, each of which is only used by one thread. Then consider this situation:
// Case A: Using distinct objects// thread 1 (performs no additional synchronization)x1.something();
// do something with x1// thread 2 (performs no additional synchronization)x2 = something_
// do something else with x2
This must always be considered correctly synchronized. Remember, we stated that x1 and x2 are distinct objects, and cannot be aliases for the same object or similar hijinks.
Second, concurrent const operations that are just reading from the same variable x must be safe:
// Case B: const access to the same object// thread 1 (performs no additional synchronization)x.something_const();
// read from x (const operation)// thread 2 (performs no additional synchronization)x.something_else_const();
// read from x (const operation)
This code too must be considered correctly synchronized, and had better work without external synchronization. It’s not a race, because the two threads are both performing const accesses and reading from the shared object.
This brings us to the case where there might be a combination of internal and external synchronization required…
(c) What partial internal synchronization can still be required within the shared variable’s implementation?
In some classes, objects that from the outside appear to be distinct but still may share state under the covers, without the calling code being able to tell that two apparently distinct objects are connected under the covers. Note that this not an exception to the previous guideline—it’s the same guideline!
Guideline: It is always true that the code that knows about and owns a writeable shared variable is responsible for synchronizing access to it. If the writeable shared state is hidden inside the implementation of some class, then it’s simply that class’ internals that are the ‘owning code’ that has to synchronize access to (just) the shared state that only it knows about.
A classic case of “under-the-covers shared state” is reference counting, and the two poster-child examples are std::shared_ptr and copy-on-write. Let’s use shared_ptr as our main example.
A reference-counted smart pointer like shared_ptr keeps a reference count under the covers. Let’s say we have two distinct shared_ptr objects sp1 and sp2, each of which is used by only one thread. Then consider this situation:
// Case A: Using distinct objects// thread 1 (performs no additional synchronization)auto x = sp1;
// read from sp1 (writes the count!) // thread 2 (performs no additional synchronization)sp2 = something_
// write to sp2 (writes the count!)
This code must be considered correctly synchronized, and had better work as shown without any external synchronization. Okay, fine …
… but what if sp1 and sp2 are pointing to the same object and so share a reference count? If so, that reference count is a writeable shared object, and so it must be synchronized to avoid a race—but it is in general impossible for the calling code to do the right synchronization, because it is not even aware of the sharing! The code we just saw above doesn’t see the count, doesn’t know the count variable’s name, and doesn’t in general know which pointers share counts.
Similarly, consider two threads just reading from the same variable sp:
// Case B: const access to the same object// thread 1 (performs no additional synchronization)auto sp3 =
// read from sp (writes the count!)// thread 2 (performs no additional synchronization)auto sp4 =
// read from sp (writes the count!)
This code too must be considered correctly synchronized, and had better work without external synchronization. It’s not a race, because the two threads are both performing const accesses and reading from the shared object. But under the covers, reading from sp to copy it increments the reference count, and so again that reference count is a writeable shared object, and so it must be synchronized to avoid a race—and again it is in general impossible for the calling code to do the right synchronization, because it is not even aware of the sharing.
So to deal with these cases, the code that knows about the shared reference count, namely the shared_ptr implementation, has to synchronize access to the reference count. For reference counting, this is typically done by making the reference count a mutable atomic variable. (See also GotW #6a and #6b.)
For completeness, yes, of course external synchronization is still required as usual if the calling code shared a given visible shared_ptr object and makes that same shared_ptr object writable across threads:
// Case C: External synchronization still required as usual//
for non-const access to same visible shared object// thread 1{
lock_guard hold(mut_sp);
// acquire lock
auto sp3 =
// read from sp}// thread 2{
lock_guard hold(mut_sp);
// acquire lock
sp = something_
// modify sp}
So it’s not like shared_ptr is a fully internal if the caller is sharing an object of that type, the caller must synchronize access to it like it would do for other types, as noted in Question 3(d).
So what’s the purpose of the internal synchronization? It’s only to do necessary synchronization on the parts that the internals know are shared and that the internals own, but that the caller can’t synchronize because he doesn’t know about the sharing and shouldn’t need to because the caller doesn’t own them, the internals do. So in the internal implementation of the type we do just enough internal synchronization to get back to the level where the caller can assume his usual duty of care and in the usual ways correctly synchronize any objects that might actually be shared.
The same applies to other uses of reference counting, such as copy-on-write strategies. It also applies generally to any other internal sharing going on under the covers between objects that appear distinct and independent to the calling code.
Guideline: If you design a class where two objects may invisibly share state under the covers, it is your class’ responsibility to internally synchronize access to that mutable shared state (only) that it owns and that only it can see, because the calling code can’t. If you opt for under-the-covers-sharing strategies like copy-on-write, be aware of the duty you’re taking on for yourself and code with care.
For why such internal shared state should be mutable, see GotW #6a and #6b.
5. … What types should be fully internally synchronized, and why?
There is exactly one category of types which should be fully internally synchronized, so that any object of that type is always safe to use concurrently without external synchronization: Inter-thread synchronization and communication primitives themselves. This includes standard types like mutexes and atomics, but also inter-thread communication and synchronization types you might write yourself such as a message queue (communicating messages from one thread to another), Producer/Consumer active objects (again passing data from one concurrent entity to another), or a thread-safe counter (communicating counter increments and decrements among multiple threads).
If you’re wondering if there might be other kinds of types that should be internally synchronized,
consider: The only type for which it would make sense to always internally synchronize every operation is a type where you know every object is going to be both (a) writeable and (b) shared across threads… and that means that the type is by definition designed to be used for inter-thread communication and/or synchronization.
Acknowledgments
Thanks in particular to the following for their feedback to improve this article: Daniel Hardman, Casey, Alb, Marcel Wid, ixache.
This GotW was written to answer a set of related frequently asked questions. So here’s a mini-FAQ on “thread safety and synchronization in a nutshell,” and the points we’ll cover apply to thread safety and synchronization in pretty much any mainstream language.
JG Questions
1. What is a race condition, and how serious is it?
2. What is a correctly synchronized program? How do you achieve it? Be specific.
Guru Questions
3. Consider the following code, where some_obj is a shared variable visible to multiple threads.
// thread 1 (performs no additional synchronization)code_that_reads_from( some_obj );
// passes some_obj by const &// thread 2 (performs no additional synchronization)code_that_modifies( some_obj );
// passes some_obj by non-const &
If threads 1 and 2 can run concurrently, is this code correctly synchronized if the type of some_obj is:
(b) string?
(c) vector&map&int,string&&?
(d) shared_ptr&widget&?
(e) mutex?
(f) condition_variable?
(g) atomic&unsigned&?
Hint: This is actually a two-part question, not a seven-part question. There are only two unique answers, each of which covers a subset of the cases.
4. External synchronization means that the code that uses/owns a given shared object is responsible for performing synchronization on that object. Answer the following questions related to external synchronization:
(a) What is the normal external synchronization responsibility of code that owns and uses a given shared variable?
(b) What is the “basic thread safety guarantee” that all types must obey to enable calling code to perform normal external synchronization?
(c) What partial internal synchronization can still be required within the shared variable’s implementation?
5. Full internal synchronization (a.k.a. “synchronized types” or “thread-safe types”) means that a shared object performs all necessary synchronization internally within that object, so that calling code does not need to perform any external synchronization. What types should be fully internally synchronized, and why?
Now the unnecessary headers have been removed, and avoidable dependencies on the internals of the class have been eliminated. Is there any further decoupling that can be done? The answer takes us back to basic principles of solid class design.
JG Question
1. What is the tightest coupling you can express in C++? And what’s the second-tightest?
Guru Question
2. The Incredible Shrinking Header has now been greatly trimmed, but there may still be ways to reduce the dependencies further. What further #includes could be removed if we made further changes to X, and how?
This time, you may make any changes at all to X as long as they don’t change its public interface, so that existing code that uses X is unaffected. Again, note that the comments are important.
x.h: after converting to use a Pimpl to hide implementation details//#include &iosfwd&#include &memory&#include "a.h"
// class A (has virtual functions)#include "b.h"
// class B (has no virtual functions)class C;class E;class X : public A, private B {public:
X( const C& );
f( int, char* );
f( int, C );
C& g( B );
virtual std::ostream& print( std::ostream& )private:
std::unique_ptr&impl&
// ptr to a forward-declared class};std::ostream& operator&&( std::ostream& os, const X& x ) {
return x.print(os);}
1. What is the tightest coupling you can express in C++? And what’s the second-tightest?
Friendship and inheritance, respectively.
A friend of a class has access to everything in that class, including all of its private data and functions, and so the code in a friend depends on every detail of the type. Now that’s a close friend!
A class derived from a class Base has access to public and protected members in Base, and depends on the size and layout of Base because it contains a Base subobject. Further, the inheritance relationship means that a derived type is at least by default substitutable for its Base; whether the inheritance is public or nonpublic only changes what other code can see and make use of the substitutability. That’s pretty tight coupling, second only to friendship.
2. What further #includes could be removed if we made further changes to X, and how?
Many programmers still seem to march to the “It isn’t OO unless you inherit!” battle hymn, by which I mean that they use inheritance more than necessary. I’ll save the whole lecture for another time, but my bottom line is simply that inheritance (including but not limited to IS-A) is a much stronger relationship than HAS-A or USES-A. When it comes to managing dependencies, therefore, you should always prefer composition/membership over inheritance wherever possible. To paraphrase Einstein: ‘Use as strong a relationship as necessary, but no stronger.’
In this code, X is derived publicly from A and privately from B. Recall that public inheritance should always model IS-A and satisfy the Liskov Substitutability Principle (LSP). In this case X IS-A A and there’s naught wrong with it, so we’ll leave that as it is.
But did you notice the curious thing about B‘s virtual functions?
“What?” you might say. “B has no virtual functions.”
B is a private base class of X. Normally, the only reason you would choose private inheritance over composition/membership is to gain access to protected members—which most of the time means “to override a virtual function.” (There are a few other rare and obscure reasons to inherit, but they’re, well, rare and obscure.) Otherwise you wouldn’t choose inheritance, because it’s almost the tightest coupling you can express in C++, second only to friendship.
We are given that B has no virtual functions, so there’s probably no reason to prefer the stronger relationship of inheritance—unless X needs access to some protected function or data in B, of course, but for now I’ll assume that this is not the case. So, instead of having a base subobject of type B, X probably ought to have simply a member object of type B. Therefore, the way to further simplify the header is:
(a) Remove unnecessary inheritance from class B.
#include "b.h"
// class B (has no virtual functions)
Because the B member object should be private (it is, after all, an implementation detail), and in order to get rid of the b.h header entirely, this member should live in X‘s hidden pimpl portion.
Guideline: Never inherit when composition is sufficient.
This leaves us with header code that’s vastly simplified from where we started in GotW #7a:
x.h: after removing unnecessary inheritance//#include &iosfwd&#include &memory&#include "a.h"
// class A (has virtual functions)class B;class C;class E;class X : public A {public:
X( const C& );
f( int, char* );
f( int, C );
C& g( B );
virtual std::ostream& print( std::ostream& )private:
std::unique_ptr&impl&
// this now quietly includes a B};std::ostream& operator&&( std::ostream& os, const X& x ) {
return x.print(os);}
After three passes of progressively greater simplification, the final result is that x.h is still using other class names all over the place, but clients of X need only pay for three #includes: a.h, memory, and iosfwd. What an improvement over the original!
Acknowledgments
Thanks in particular to the following for their feedback to improve this article: juanchopanza, anicolaescu, Bert Rodiers.
Now the unnecessary headers have been removed, and avoidable dependencies on the internals of the class have been eliminated. Is there any further decoupling that can be done? The answer takes us back to basic principles of solid class design.
JG Question
1. What is the tightest coupling you can express in C++? And what’s the second-tightest?
Guru Question
2. The Incredible Shrinking Header has now been greatly trimmed, but there may still be ways to reduce the dependencies further. What further #includes could be removed if we made further changes to X, and how?
This time, you may make any changes at all to X as long as they don’t change its public interface, so that existing code that uses X is unaffected. Again, note that the comments are important.
x.h: after converting to use a Pimpl to hide implementation details//#include &iosfwd&#include &memory&#include "a.h"
// class A (has virtual functions)#include "b.h"
// class B (has no virtual functions)class C;class E;class X : public A, private B {public:
X( const C& );
f( int, char* );
f( int, C );
C& g( B );
virtual std::ostream& print( std::ostream& )private:
std::unique_ptr&impl&
// ptr to a forward-declared class};std::ostream& operator&&( std::ostream& os, const X& x ) {
return x.print(os);}
Now that the unnecessary headers have been removed, it’s time for Phase 2: How can you limit dependencies on the internals of a class?
JG Questions
1. What does private mean for a class member in C++?
2. Why does changing the private members of a type cause a recompilation?
Guru Question
3. Below is how the header from the previous Item looks after the initial cleanup pass. What further #includes could be removed if we made some suitable changes, and how?
This time, you may make changes to X as long as X‘s base classes and its public interf any current code that already uses X should not be affected beyond requiring a simple recompilation.
x.h: sans gratuitous headers//#include &iosfwd&#include &list&// None of A, B, C, or D are templates.// Only A and C have virtual functions.#include "a.h"
// class A#include "b.h"
// class B#include "c.h"
// class C#include "d.h"
// class Dclass E;class X : public A, private B {public:
X( const C& );
f( int, char* );
f( int, C );
C& g( B );
virtual std::ostream& print( std::ostream& )
std::list&C&
D};std::ostream& operator&&( std::ostream& os, const X& x ) {
return x.print(os);}
1. What does private mean for a class member in C++?
It means that outside code cannot access that member. Specifically, it cannot name it or call it.
For example, given this class:
class widget {public:
void f() { }private:
void f(int) { }};
Outside code cannot use the name of the private members:
int main() {
auto w = widget{};
// error, cannot access name "f(int)"
// error, cannot access name "i"}
2. Why does changing the private members of a type cause a recompilation?
Because private data members can change the size of the object, and private member functions participate in overload resolution.
Note that accessibility is still safely enforced: Calling code still doesn’t get to use the private parts of the class. However, the compiler gets to know all about them at all times, including as it compiles the calling code. This does increase build coupling, but it’s for a deliberate reason: C++ has always been designed for efficiency, and a little-appreciated cornerstone of that is that C++ is designed to by default expose a type’s full implementation to the compiler in order to make aggressive optimization easier. It’s one of the fundamental reasons C++ is an efficient language.
3. What further #includes could be removed if we made some suitable changes, and how? … any current code that already uses X should not be affected beyond requiring a simple recompilation.
There are a few things we weren’t able to do in the previous problem:
We had to leave a.h and b.h. We couldn’t get rid of these because X inherits from both A and B, and you always have to have full definitions for base classes so that the compiler can determine X‘s object size, virtual functions, and other fundamentals. (Can you anticipate how to remove one of these? Think about it: Which one can you remove, and why/how? The answer will come shortly.)
We had to leave list, c.h and d.h. We couldn’t get rid of these right away because a list&C& and a D appear as private data members of X. Although C appears as neither a base class nor a member, it is being used to instantiate the list member, and some have compilers required that when you instantiate list&C& you be able to see the definition of C. (The standard doesn’t require a definition here, though, so even if the compiler you are currently using has this restriction, you can expect the restriction to go away over time.)
Now let’s talk about the beauty of Pimpls.
The Pimpl Idiom
C++ lets us easily encapsulate the private parts of a class from unauthorized access. Unfortunately, because of the header file approach inherited from C, it can take a little more work to encapsulate dependencies on a class’ privates.
“But,” you say, “the whole point of encapsulation is that the client code shouldn’t have to know or care about a class’ private implementation details, right?” Right, and in C++ the client code doesn’t need to know or care about access to a class’ privates (because unless it’s a friend it isn’t allowed any), but because the privates are visible in the header the client code does have to depend upon any types they mention. This coupling between the caller and the class’s internal details creates dependencies on both (re)compilation and binary layout.
How can we better insulate clients from a class’ private implementation details? One good way is to use a special form of the handle/body idiom, popularly called the Pimpl Idiom because of the intentionally pronounceable pimpl pointer, as a compilation firewall.
A Pimpl is just an opaque pointer (a pointer to a forward-declared, but undefined, helper class) used to hide the private members of a class. That is, instead of writing this:
// file widget.h//class widget {
// public and protected membersprivate:
// whenever these change,
// all client code must be recompiled};
We write instead:
// file widget.h//#include &memory&class widget {public:
~widget();
// public and protected membersprivate:
std::unique_ptr&impl&
// ptr to a forward-declared class};// file widget.cpp//#include "widget.h"struct widget::impl {
// fully hidden, can be
// changed at will without recompiling clients};widget::widget() : pimpl{ make_unique&widget::impl&(/*...*/) } { }widget::~widget() =
Every widget object dynamically allocates its impl object. If you think of an object as a physical block, we’ve essentially lopped off a large chunk of the block and in its place left only “a little bump on the side”—the opaque pointer, or Pimpl. If copy and move are appropriate for your type, write those four operations to perform a deep copy that clones the impl state.
The major advantages of this idiom come from the fact that it breaks the caller’s dependency on the private details, including breaking both compile-time dependencies and binary dependencies:
Types mentioned only in a class’ implementation need no longer be defined for client code, which can eliminate extra #includes and improve compile speeds.
A class’ implementation can be changed—that is, private members can be freely added or removed—without recompiling client code. This is a useful technique for providing ABI-safety or binary compatibility, so that the client code is not dependent on the exact layout of the object.
The major costs of this idiom are in performance:
Each construction/destruction must allocate/deallocate memory.
Each access of a hidden member can require at least one extra indirection. (If the hidden member being accessed itself uses a back pointer to call a function in the visible class, there will be multiple indirections, but is usually easy to avoid needing a back pointer.)
And of course we’re replacing any removed headers with the &memory& header.
We’ll come back to these and other Pimpl issues in GotW #24. For now, in our example, there were three headers whose definitions were needed simply because they appeared as private members of X. If we instead restructure X to use a Pimpl, we can immediately make several further simplifications:
#include &list&#include "c.h"
// class C#include "d.h"
// class D
One of these headers (c.h) can be replaced with a forward declaration because C is still being mentioned elsewhere as a parameter or return type, and the other two (list and d.h) can disappear completely.
Guideline: For widely-included classes whose implementations may change, or to provide ABI-safety or binary compatibility, consider using the compiler-firewall idiom (Pimpl Idiom) to hide implementation details. Use an opaque pointer (a pointer to a declared but undefined class) declared as
std::unique_ptr&impl& to store private nonvirtual members.
Note: We can’t tell from the original code by itself whether or not X had (default) copy or move operations. If it did, then to preserve that we would need to write them again ourselves since the move-only unique_ptr member suppresses the implicit generation of copy construction and copy assignment, and the user-declared destructor suppresses the implicit generation of move construction and move assignment. If we do need to write them by hand, the move constructor and move assignment can be =defaulted, and the copy constructor and copy assignment will need to copy the Pimpl object.
After making that additional change, the header looks like this:
x.h: after converting to use a Pimpl//#include &iosfwd&#include &memory&#include "a.h"
// class A (has virtual functions)#include "b.h"
// class B (has no virtual functions)class C;class E;class X : public A, private B {public:
// defined out of line
// and copy/move operations if X had them before
X( const C& );
f( int, char* );
f( int, C );
C& g( B );
virtual std::ostream& print( std::ostream& )private:
std::unique_ptr&impl&
// ptr to a forward-declared class};std::ostream& operator&&( std::ostream& os, const X& x ) {
return x.print(os);}
Without more extensive changes, we still need the definitions for A and B because they are base classes, and we have to know at least their sizes in order to define the derived class X.
The private details go into X‘s implementation file where client code never sees them and therefore never depends upon them:
Implementation file x.cpp//#include &list&#include "c.h"
// class C#include "d.h"
// class Dstruct X::impl {
D};X::X() : pimpl{ make_unique&X::impl&(/*...*/) } { }X::~X() =
That brings us down to including only four headers, which is a great improvement—but it turns out that there is still a little more we could do, if only we were allowed to change the structure of X more extensively. This leads us nicely into Part 3…
Acknowledgments
Thanks to the following for their feedback to improve this article: John Humphrey, thokra, Motti Lanzkron, Marcelo Pinto.
Now that the unnecessary headers have been removed, it’s time for Phase 2: How can you limit dependencies on the internals of a class?
JG Questions
1. What does private mean for a class member in C++?
2. Why does changing the private members of a type cause a recompilation?
Guru Question
3. Below is how the header from the previous Item looks after the initial cleanup pass. What further #includes could be removed if we made some suitable changes, and how?
This time, you may make changes to X as long as X‘s base classes and its public interf any current code that already uses X should not be affected beyond requiring a simple recompilation.
x.h: sans gratuitous headers
#include &iosfwd&
#include &list&
// None of A, B, C, or D are templates.
// Only A and C have virtual functions.
#include "a.h"
// class A
#include "b.h"
// class B
#include "c.h"
// class C
#include "d.h"
// class D
class X : public A, private B {
X( const C& );
f( int, char* );
f( int, C );
C& g( B );
virtual std::ostream& print( std::ostream& )
std::list&C&
std::ostream& operator&&( std::ostream& os, const X& x ) {
return x.print(os);
Follow &Sutter’s Mill&
Get every new post delivered to your Inbox.
Join 2,565 other followers
Add your thoughts here... (optional)}