Combining C++ header files

问题

Is there an automated way to take a large amount of C++ header files and combine them in a single one?

This operation must, of course, concatenate the files in the right order so that no types, etc. are defined before they are used in upcoming classes and functions.

Basically, I'm looking for something that allows me to distribute my library in two files (libfoo.h, libfoo.a), instead of the current bunch of include files + the binary library.

回答1:

As your comment says:

.. I want to make it easier for library users, so they can just do one single #include and have it all.

Then you could just spend some time, including all your headers in a "wrapper" header, in the right order. 50 headers are not that much. Just do something like:

// libfoo.h
#include "header1.h"
#include "header2.h"
// ..
#include "headerN.h"

This will not take that much time, if you do this manually.

Also, adding new headers later - a matter of seconds, to add them in this "wrapper header".

In my opinion, this is the most simple, clean and working solution.

回答2:

If your library is so big that you cannot build and maintain a single wrapping header file like Kiril suggested, this may mean that it is not architectured well enough.

So if your library is really huge (above a million lines of source code), you might consider automating that, with tools like

GCC make dependency generator preprocessor options like -M -MD -MF etc, with another hand made script sorting them
expensive commercial static analysis tools like coverity
customizing a compiler thru plugins or (for GCC 4.6) MELT extensions

But I don't understand why you want an automated way of doing this. If the library is of reasonable size, you should understand it and be able to write and maintain a wrapping header by hand. Automating that task will take you some efforts (probably weeks, not minutes) so is worthwhile only for very large libraries.

回答3:

A little bit late, but here it is. I just recently stumbled into this same problem myself and coded this solution: https://github.com/rpvelloso/oneheader

How does it works?

Your project's folder is scanned for C/C++ headers and a list of headers found is created;

For every header in the list it analyzes its #include directives and assemble a dependency graph in the following way:

If the included header is not located inside the project's folder then it is ignored (e.g., if it is a system header);

If the included header is located inside the project's folder then an edge is create in the dependency graph, linking the included header to the current header being analyzed;

The dependency graph is topologically sorted to determine the correct order to concatenate the headers into a single file. If a cycle is found in the graph, the process is interrupted (i.e., if it is not a DAG);

Limitations:

It currently only detects single line #include directives (e.g., #include );

It does not handles headers with the same name in different paths;

It only gives you a correct order to combine all the headers, you still need to concatenate them (maybe you want remove or modify some of them prior to merging).

Compiling:

g++ -Wall -ggdb -std=c++1y -lstdc++fs oneheader.cpp -o oneheader[.exe]

Usage:

./oneheader[.exe] project_folder/ > file_sequence.txt

回答4:

_{(Adapting an answer to my dupe question:)}

There are several other libraries which aim for a single-header form of distribution, but are developed using multiple files; and they too need such a mechanism. For some (most?) it is opaque and not part of the distributed code. Luckily, there is at least one exception: Lyra, a command-line argument parsing library; it uses a Python-based include file fuser/joiner script, which you can find here.

The script is not well-documented, but they way you use it is with 3 command-line arguments:

--src-include - The include file to convert, i.e. to merge its include directives into its body. In your case it's libfoo.h which includes the other files.
--dst-include - The output file to write - the result of the merging.
--src-include-dir - The directory relative to which include files are specified (i.e. an "include search path" of one directory; the script doesn't support the complex mechanism of multiple include paths and search priorities which the C++ compiler offers)

The script acts recursively, so if file1.h includes another file under the --src-include-dir, that should be merged in as well.

Now, I could nitpick at the code of that script, but - hey, it works and it's FOSS - distributed with the Boost license.

回答5:

If you have a master include file that includes all others available, you could simply hack a C preprocessor re-implementation in Perl. Process only ""-style includes and recursively paste the contents of these files. Should be a twenty-liner.

If not, you have to write one up yourself or try at random. Automatic dependency tracking in C++ is hard. Like in "let's see if this template instantiation causes an implicit instantiation of the argument class" hard. The only automated way I see is to shuffle your include files into a random order, see if the whole bunch compiles, and re-shuffle them until it compiles. Which will take n! time, you might be better off writing that include file by hand.

While the first variant is easy enough to hack, I doubt the sensibility of this hack, because you want to distribute on a package level (source tarball, deb package, Windows installer) instead of a file level.

回答6:

You really need a build script to generate this as you work, and a preprocessor flag to disable use of the amalgamate (that could be for your uses).

To simplify this script/program, it helps to have your header structures and include hygiene in top form.

Your program/script will need to know your discovery paths (hint: minimise the count of search paths to one if possible).
Run the script or program (which you create) to replace include directives with header file contents.
Assuming your headers are all guarded as is typical, you can keep track of what files you have already physically included and perform no action if there is another request to include them. If a header is not found, leave it as-is (as an include directive) -- this is required for system/third party headers -- unless you use a separate header for external includes (which is not at all a bad idea).
It's good to have a build phase/translation that includes header alone and produces zero warnings or errors (warnings as errors).

Alternatively, you can create a special distribution repository so they never need to do more than pull from it occasionally.

回答7:

What you want to do sounds "javascriptish" to me :-) . But if you insist, there is always "cat" (or the equivalent in Windows):

$ cat file1.h file2.h file3.h > my_big_file.h

Or if you are using gcc, create a file my_decent_lib_header.h with the following contents:

#include "file1.h"
#include "file2.h"
#include "file3.h"

and then use

$ gcc -C -E my_decent_lib_header.h -o my_big_file.h

and this way you even get file/line directives that will refer to the original files (although that can be disabled, if you wish).

As for how automatic is this for your file order, well, it is not at all; you have to decide the order yourself. In fact, I would be surprised to hear that a tool that orders header dependencies correctly in all cases for C/C++ can be built.

回答8:

usually you don't want to include every bit of information from all your headers into the special header that enables the potential user to actually use your library. The non-trivial removal of type definitions, further includes or defines, that are not necessary for the user of your interface to know can not be automatedly done. As far as I know.

Short answer to your main question:

My suggestions:

manually make a new header, that contains all relevant information (nothing more, nothing less) for the user of your library interface. Add nice documentation comments for each component it contains.
use forward declarations where possible, instead of full-fledged included definitions. Put the actual includes in your implementation files. The less include statements you have in your headers, the better.
don't build a deeply nested hierarchy of includes. This makes it extremely hard to keep an overview on the contents of every bit you include. The user of your library will look into the header to learn how to use it. And he will probably not be able to distinguish relevant code from irrelevant on the first sight. You want to maximize the ratio of relevant code per total code in the main header for your library.

EDIT

If you really do have a toolkit library, and the order of inclusion really does not matter, and you have a bunch of independent headers, that you want to enumerate just for convenience into a single header, then you can use a simple script. Like the following Python (untested):

import glob
with open("convenience_header.h", 'w') as f:
  for header in glob.glob("*.h"):
    f.write("#include \"%s\"\n" % header)

来源：https://stackoverflow.com/questions/8412347/combining-c-header-files

标签

c++

include

header-files