Why would you want to put a class in an implementation file?

Question

While looking over some code, I ran into the following:

.h file

class ExampleClass
{
public:
    // methods, etc
private:
    class AnotherExampleClass* ptrToClass;
}

.cpp file

class AnotherExampleClass
{
    // methods, etc
}

// AnotherExampleClass and ExampleClass implemented

Is this a pattern or something beneficial when working in c++? Since the class is not broken out into another file, does this work flow promote faster compilation times?

or is this just the style this developer?

@MadPhysicist the guts of the class. I didn't put anything in because it doesn't really relate to the problem. — afuzzyllama, Aug 13 '14 at 15:40
Pimpl idiom. This is used to avoid long compilation times. And also sometimes for a sort of binary compatibility. The `AnotherExampleClass` class is an implementation detail. — Synxis, Aug 13 '14 at 15:40
An awful kind of pimple idiom. There are better ways. I guess your developer lives in the past — BЈовић, Aug 13 '14 at 16:06
http://stackoverflow.com/questions/9020372/how-do-i-use-unique-ptr-for-pimpl — BЈовић, Aug 14 '14 at 06:30

score 25 · Accepted Answer · answered Aug 13 '14 at 15:39

This is variously known as the pImpl Idiom, Cheshire cat technique, or Compilation firewall.

Benefits:

Changing private member variables of a class does not require recompiling classes that depend on it, thus make times are faster, and the FragileBinaryInterfaceProblem is reduced.

The header file does not need to #include classes that are used 'by value' in private member variables, thus compile times are faster.

This is sorta like the way SmallTalk automatically handles classes... more pure encapsulation.

Drawbacks:

More work for the implementor.

Doesn't work for 'protected' members where access by subclasses is required.

Somewhat harder to read code, since some information is no longer in the header file.

Run-time performance is slightly compromised due to the pointer indirection, especially if function calls are virtual (branch prediction for indirect branches is generally poor).

Herb Sutter's "Exceptional C++" books also go into useful detail on the appropriate usage of this technique.

Thanks for all the resources! I figured it was something along those lines, but I didn't know about the "pImpl Idiom". — afuzzyllama, Aug 13 '14 at 15:45
Yeah, once you know the name for it, it's easy to learn everything else about it. — bgporter, Aug 13 '14 at 17:07

score 11 · Answer 2 · answered Aug 13 '14 at 15:41

11

The most common example would be when using the PIMPL pattern or similar techniques. Still, there are other uses as well. Typically, the distinction .hpp/.cpp in C++ is rather (or, at least can be) one of public interface versus private implementation. If a type is only used as part of the implementation, then that's a good reason not to export it in the header file.

answered Aug 13 '14 at 15:41

Ulrich Eckhardt

15,392
1
25
49

Thanks for the insight! – afuzzyllama Aug 13 '14 at 15:44

score 7 · Answer 3 · answered Aug 13 '14 at 15:50

Apart from possibly being an implementation of the PIMPL idiom, here are two more possible reason to do this:

Objects in C++ cannot modify their this pointer. As a consequence, they cannot change type in mid-usage. However, ptrToClass can change, allowing an implementation to delete itself and to replace itself with another instance of another subclass of AnotherExampleClass.

If the implementation of AnotherExampleClass depends on some template parameters, but the interface of ExampleClass does not, it is possible to use a template derived from AnotherExampleClass to provide the implementation. This hides part of the necessary, yet internal type information from the user of the interface class.

Why would you want to put a class in an implementation file?

3 Answers3