Is including C++ source files an approved method?

Question

I have a large C++ file (SS.cpp) which I decided to split in smaller files so that I can navigate it without the need of aspirins. So I created

SS_main.cpp
SS_screen.cpp
SS_disk.cpp
SS_web.cpp
SS_functions.cpp

and cut-pasted all the functions from the initial SS.cpp file to them.

And finally I included them in the original file :

#include "SS_main.cpp"
#include "SS_screen.cpp" 
#include "SS_disk.cpp" 
#include "SS_web.cpp"
#include "SS_functions.cpp"

This situation remains for some months now , and these are the problems I've had :

• The Entire Solution search (Shift-Ctrl-F in VS) does not search in the included files, because they are not listed as source files.

• I had to manually indicate them for Subversion inclusion.

Do you believe that including source files in other sources is an accepted workaround when files go really big ? I should say that splitting the implemented class in smaller classes is not an option here.

Answer 1

There are times when it's okay to include an implementation file, but this doesn't sound like one of them. Usually this is only useful when dealing with certain auto-generated files, such as the output of the MIDL compiler. As a workaround for large files, no.

You should just add all of those source files to your project instead of #including them. There's nothing wrong with splitting a large class into multiple implementation files, but just add them to your project, including them like that doesn't make much sense.

-- Also, as an FYI, you can add files to your projects, and then instruct the compiler to ignore them. This way they're still searchable. To do this, add the file to the project, then right-click it, and go to Properties, and under "General" set "Exclude from Build" to Yes.

Answer 2

Don't include cpp files in other files. You don't have to define every class function in one file, you can spread them across multiple files. Just add them individually to the project and have it compile all of them separately.

Answer 3

You don't include implementation (.cpp) files. Create header files for these implementation files containing the function/class declarations and include these as required.

Answer 4

There are actually times you will want to include CPP files. There are several questions here about Unity Builds which discuss this very topic.

Answer 5

You need to learn about Separate compilation, linking, and what header files are for.

You need to create a header file for each of those modules (except possibly main.cpp). The header file will contain the declarative parts of each .cpp source file, and the .cpp files themselves will contain the instantive parts. Each unit can then be separately compiled and linked. For example:

main.cpp

#include "function.h"

int main()
{
    func1() ;
}

---

function.h

#if !defined FUNCTION_H
#define FUNCTION_H

extern void func1() ;

#endif

---

function.cpp

void func1()
{
    // do stuff
}

---

Then function.cpp and main.cpp are separately compiled (by adding them to the sources for the project), and then linked. The header file is necessary so that the compiler is made aware of the interface to func1() without seeing the complete definition. The header should be added to the project headers, then you will find that the source browser and auto-completion etc. work correctly.

Answer 6

What bothers me with this question is the context of it. A large cpp file has been created, large enough to warrant thinking about splitting it into smaller more manageable files. The proposed split is:
SS_main.cpp
SS_screen.cpp
SS_disk.cpp
SS_web.cpp
SS_functions.cpp

This seems to indicate that there are separate units of functionality from a specification and design perspective. We can only guess at the coupling between these units of code.

However, it would be a start to define these code units such that each new cpp file has its own header file thus defining the interfaces of these units and the (low) coupling between them to achieve (high) cohesion for each unit.

We are refactoring here.

It is not acceptable to use included cpp files in this context it as does not provide any advantages. The only time I've come across included cpp files is when a one is included to provide code for debug code, and example being to compile non-inline versions of functions. It helps in stepping through code in the debugger.