One class with multiple implementation files

Question

Is there anything wrong with having a single class (one .h) implemented over multiple source files? I realize that this could be a symptom of too much code in a single class, but is there anything technically wrong with it?

For instance:

Foo.h

class Foo
{
   void Read();
   void Write();
   void Run();
}

Foo.Read.cpp

#include "Foo.h"
void Foo::Read()
{
}

Foo.Write.cpp

#include "Foo.h"
void Foo::Write()
{
}

Foo.Run.cpp

#include "Foo.h"
void Foo::Run()
{
}

Answer 1

Nope, nothing technically wrong with it. The linker will bring all the pieces of Foo together in the final binary.

Answer 2

This is fine. In the end, it will be all linked together.

I have even seen code, where every member function was in a different *.cpp file.

Answer 3

I've been working with the Apache Portable Runtime, which does pretty much this exact thing. You have a header, say apr_client.h and multiple implementation files for the functions in that header -- each file representing one aspect of client operations. It's not wrong, and it's not really unusual.

this could be a symptom of too much code in a single class

C++ is not Java, so you don't have to pick your file names according to your class names.

Answer 4

yea thats legitmate, and in fact newer languages like C# do that sort of thing of all the time.

Answer 5

That is legitimate and it has some (!?) advantages...

If you link your executable with the static library of this class, only the used functions will get in. This is very handy for limited-resource systems.

You can also hide implementation details of certain functions. Two people may implement parts of a class without knowing about each other. Handy for DOD projects.

If you look at any CRT source, you will see the same pattern...

Answer 6

It is perfectly valid. All cpp files will be linked together.

This can be useful for, as you said, making a very large implementation file more readable and, since each cpp file is a compilation unit, you could (ab)use that fact. (Unnamed namespaces for example)

Answer 7

There are two points which may be worth considering.

Class wide optimisations:

If the compiler has all of the member functions visible to it when its parsing the file (assuming a single TU compiler) then it may be able to perform optimisations between the different member functions.

Code Review

If all the definitions for a class are in the same TU, then this makes manual code review easier. If the definitions are split into different TUs, this significantly increases the effort required for a manual review as the appropriate files need to be searched for, with constant flicking between windows to get the "whole" picture.