Using Me. The using directive is a contentious feature -- more contentious, in fact, than it needs to be. If you choose to use it, this article examines some rules and guidelines around its use.

Im-Paired Programming. std::pair can make your life easier. But as with many things, moderation is the key: excessive use can lead to unmanageable code.

Virtually Misbehavin'. C++ implicit overriding at work.

Of Many Things. “The time has come,” the Walrus said, “to talk of many things. Of std::string -- and magic numbers -- and constness in references.”

Reusing Streams. There once was a stream reuse style / After close() to re-open() a while / And the questions grew hot: / “Will it open or not? / Is the style ‘clearly’ vile, or worthwhile?”

Pointing in the Right Direction. What’s in a pointer? Not much, really. Raw pointers invite memory leaks – because they cannot tell the programmer how they should be handled.

Self-Sufficient Headers. A good C++ (and C) coding standard is that every header file should be self-sufficient. But is it always so? This article looks at the coding standard, how it applies in the presence of templates and member templates, and how nonmember functions can improve modular dependencies in addition to encapsulation.

From C++ to Shining C. So you have a C++ type, and you have a C program that wants to use it. Is it a case of “never the twain shall meet,” or can true objects be reasonably exposed to non-object oriented languages? The twain can indeed meet, and this article shows how.

Factory Redux, Part 2. Continuing to revisit the Template Method factory, with a generic<twist> to it.

Factory Redux, Part 1. Revisiting the Template Method factory, with a generic<twist> to it.

Imagine. If you want to write portable code, you're going to need a lot of conditional compilation -- #if this, #else that --, right? Imagine if that were not the case...

Delegating Constructors? Delegating constructors aren’t (yet) supported in the C++ Standard. This article demonstrates the common technique that gets us most of the way there in Standard C++, and its drawbacks. It also demonstrates that Standard C++ does allow two apparent “workarounds” that may look good at first, but which are bad and atrocious, respectively – one of them is a simple mistake, the other an outright appeal to Machiavelli.

Sharing Causes Contention. Following up on themes introduced in the two preceding Conversations columns, the Guru demonstrates why needless sharing might be considered harmful.

Once Is Not Enough. Some reasons why the ubiquitous Singleton Pattern is, perhaps, a little too ubiquitous.

Points of Order. Of shoes, socks, arguments, and locks: Why order is important in programming as in life.

Value Lessons. When is an object not an object? When it is a value. Knowing when to use value types and when to use object types can simplify your design.

It's an Object-Ful Lifetime (by Jim Hyslop). References, temporaries, and accidental references to temporaries... a full stomach can make one dream up all sorts of creative problems and solutions.

Truth or Consequences. What’s wrong with using bool as a parameter? There are usually better ways to express what you mean. This month we turn to an expert who died before Stroustrup was born.

Contracts, Promises, and Mere Semantics. What is a function saying when it takes a parameter by pointer, by reference, or by value? When interface idioms lie, sometimes there's no graceful way to avoid the surprises.

Baseless Exceptions. Implicit conversion sequences can be quite useful. But there are... well... exceptions to when they are applied.

A Midsummer Night's Madness. What do you get when you add a pointer to a typedef and mix in const? The Guru puts in her thoughts on the matter.

Getting to the Point. While the standard auto_ptr provides a safer alternative to raw pointers, it has its limitations, and some surprising behavior. The Guru helps out by giving the narrator a boost – library, that is. The Boost library has five smart pointers that provide a rich array of useful behavior.

The Good, the Bad, and the Deprecated. What can go wrong when your code gives you a bit too much... er... static.

Making a Real Hash of Things. Speed often does matter. But what kind of "speed" is important when it comes to associative containers?

To Sleep, Perchance. Just how many threading and streaming mistakes can arise in one poor little dozen-line function? Quite a few, and that's not even counting the magic...

Template Specializations, Default Parameters, and Other Fun Stuff. Many people know how to partially specialize a template. But what happens when the base template has a template parameter with a default value? The answer may not be quite what Bob expected...

New Bases, Part 2. Basic reading and writing from a standard stream sounds simple, but can harbor its share of little complexities. Here is a simple example, with notes about the kinds of complexity that can usually be deferred.

New Bases, Part 1. Converting a text-represented number from one base to another is pretty simple. But how extensible and reusable can the solution be to solve more than one problem, when there are also additional requirements?

I'd Hold Anything for You. There are occasions when you have a variable whose type you don't know until run time. Thanks to the Boost library, there is a safe alternative to fragile union- or void*-based solutions.