Where does the C++ compiler start?

开发者_如何学PythonIf you have a c++ project with several source files and you hit compile, which file does the compiler start with?

I am asking cause I am having some #include-dependency issues on a library.

Compiler would be: VC2003.

It should not be order-dependent. The only relevant steps are:

1. Each compilation unit includes what it depends on, and should be compilable individually. This means, first, that each CPP file includes all the headers it depends on; and second, that each header should in turn include what it needs so that it can compile even if it is the first one to be compiled.
2. A link step puts all the compiled object code together and builds the final binary.

It should not matter which file it starts with, the linker resolves external references after all the files have been compiled

Irrelevant. Post the exact issue. The compilation order is non-deterministic and arbitrary, and must have no effect on the compilability of your project.

This depends on the environment. In general a "compiler" only works on a single source file at a time; you use higher-level tools to direct it and compute the proper build order.

Examples of such tools can be make, ant, CMake, SCons, Eclipse, and Visual Studio. A basic check is generally the modification date of the source code files, coupled with built-in and custom rules that define how various output files depend on the inputs.

The order the compiler compiles in shouldn't make a difference, as others have noted.

From the compiler's point of view, when you compile a file with a #include, the included file is inserted into the file being compiled at the point where the #include is, recursing as necessary.

Others have already said that the order shouldn't make a difference.

What you might not have realized is that the compiler compiles every .cpp or .cc file. It does not compile header files. And typically, you only #include header files, and never .cpp files, so the order does not matter. Every .cpp file is processed in isolation. It includes a number of headers, but these are never compiled separately, and it does not typically include other .cpp files either.

The only "include-dependency" problem I can think of is a recursive inclusion. For which the fix normally is guarding it with #ifdef

#ifndef INCLUDED_THEFILENAME_H
#define INCLUDED_THEFILENAME_H

/* content goes here *

#endif

But you better elaborate on the issue you're having.

As others have pointed out, conceptually it is not important which file it starts with. However, it can be useful to start with the most recently edited file (assuming more than one file has been edited) of with the file with the most dependencies. Some environments, such as Code::Blocks, actually allow you to give weightings to source files to give you some control over the compilation order.

A make tool builds a directed acyclic graph of the dependencies specified in the make file. This will normally say the executable depends on a number of object files. The object files depends on source files, each source file depends on headers, and so on.

This produces essentially a multi-way tree. The tree will have the executable as its root, and typically have mostly headers as the leaf nodes (though if you're using some sort of code generator, it could also have the input file for that code generator as a leaf).

It then walks that tree working its way from the leaf nodes to the root node and building as it goes. The answers that have said "it doesn't matter" are basically pointing out that it can pick any branch of that tree to build first. It does matter, however, that when it picks a branch, it builds in the order specified for that branch.