Where do I learn "what I need to know" about C++ compilers?

c, c++, compiler-construction

Solution

Concerning the "numerous options of the various compilers" A piece of good news: you needn't worry about the detail of most of these options. You will, in due time, delve into this, only for the very compiler you use, and maybe only for the options that pertain to a particular set of features. But as a novice, generally trust the default options or the ones supplied with the make files.

The broad categories of these features (and I may be missing a few) are:

- pre-processor defines (now, you may need a few of these)

- code generation (target CPU, FPU usage...)

- optimization (hints for the compiler to favor speed over size and such)

- inclusion of debug info (which is extra data left in the object/binary and which enables the debugger to know where each line of code starts, what the variables names are etc.)

- directives for the linker

- output type (exe, library, memory maps...)

- C/C++ language compliance and warnings (compatibility with previous version of the compiler, compliance to current and past C Standards, warning about common possible bug-indicative patterns...)

- compile-time verbosity and help

Concerning an inventory of compilers with their options and features I know of no such list but I'm sure it probably exists on the web. However, suggest that, as a novice you worry little about these "details", and use whatever free compiler you can find (gcc certainly a great choice), and build experience with the language and the build process. C professionals may likely argue, with good reason and at length on the merits of various compilers and associated runtine etc., but for generic purposes -and then some- the free stuff is all that is needed.

Concerning the build process The most trivial applications, such these made of a single unit of compilation (read a single C/C++ source file), can be built with a simple batch file where the various compiler and linker options are hardcoded, and where the name of file is specified on the command line. For all other cases, it is very important to codify the build process so that it can be done a) automatically and b) reliably, i.e. with repeatability. The "recipe" associated with this build process is often encapsulated in a make file or as the complexity grows, possibly several make files, possibly "bundled together in a script/bat file. This (make file syntax) you need to get familiar with, even if you use alternatives to make/nmake, such as Apache Ant; the reason is that many (most?) source code packages include a make file. In a nutshell, make files are text files and they allow defining targets, and the associated command to build a target. Each target is associated with its dependencies, which allows the make logic to decide what targets are out of date and should be rebuilt, and, before rebuilding them, what possibly dependencies should also be rebuilt. That way, when you modify say an include file (and if the make file is properly configured) any c file that used this header will be recompiled and any binary which links with the corresponding obj file will be rebuilt as well. make also include options to force all targets to be rebuilt, and this is sometimes handy to be sure that you truly have a current built (for example in the case some dependencies of a given object are not declared in the make).

On the Pre-processor: The pre-processor is the first step toward compiling, although it is technically not part of the compilation. The purposes of this step are:

- to remove any comment, and extraneous whitespace

- to substitute any macro reference with the relevant C/C++ syntax. Some macros for example are used to define constant values such as say some email address used in the program; during per-processing any reference to this constant value (btw by convention such constants are named with `ALL_CAPS_AND_UNDERSCORES`) is replace by the actual C string literal containing the email address.

- to exclude all conditional compiling branches that are not relevant (the #IFDEF and the like)

What's important to know about the pre-processor is that the pre-processor directive are NOT part of the C-Language proper, and they serve several important functions such as the conditional compiling mentionned earlier (used for example to have multiple versions of the program, say for different Operating Systems, or indeed for different compilers)

Taking it from there... After this manifesto of mine... I encourage to read but little more, and to dive into programming and building binaries. `It is a very good idea to try and get a broad picture of the framework etc. but this can be overdone`, a bit akin to the exchange student who stays in his/her room reading the Webster dictionary to be "prepared" for meeting native speakers, rather than just "doing it!".

Problem

Original source