Factor away nonessential complexity into local inline helper functions and helper classes.
Think clearly about internal invariants that apply to each class, and document them in the form of asserts within member functions.
Make simple, self-evident contracts for class methods. If you cannot communicate a simple contract, redesign the class.
Implement classes as if expecting rough usage by clients. Rough use that breaks a class must throw an assert.
When possible, try to design as if for reusability, simply because this forces a clear design of the class's externals, and clean hiding of its internals.
Initialize all variables and data structures to a known state. If a class has a constructor, initialize it there.
Do no optimization before its time. Prove the need to optimize.
When you must defactor to optimize, preserve as much structure as possible. If you must hand-inline some name, label the local copy with the original name.
If you need to use a hidden detail (e.g., a structure offset), name it (as a constant or function) in the class the owns it.
Don't use the Copy and Paste keys to replicate more than a couple lines of code. Name what you must repeat.
Don't give two names to the same thing. Try not to give two names similar things: Derive one from the other or both from a private third.
When choosing names, avoid categorical nouns like "variable", "field", "parameter", "value", and verbs like "compute", "get". ("storeValue(int param)" is bad.)
Names should be verb phrases that reflect changes of state known to a class's user, or else noun phrases if they cause no change of state visible to the class's user.
If a class needs a method to change a user-visible attribute, the change should be done with a "setter" accessor matched to the simple "getter".
Choose names consistently. Do not introduce spurious variations. Abbreviate corresponding terms to a consistent length.
Be sparing and tasteful with C++ function overloading and optional arguments, because they will easily confuse the reader.
Take care to avoid fancy C++ features, such as operator overloading, copy constructors, implicit conversions, covariance, etc.
Absolutely avoid multiple inheritance, exceptions, namespaces. Introduce new templates only by Act of Congress..