Everyone is welcome to add links to tutorials, HOWTOs, cheat sheets, etc that may be floating around the net.

Consider the following example: Let “hello.C” be a file that contains the following C++ code.

#include "iostream.h"
int main() 
{
  cout << "Hello\n";
} 

The standard way to compile this program is with the command

Lab46:~$ g++ hello.C -o hello 

This command compiles hello.C into an executable program named “hello” that you run by typing 'hello' at the command line. It does nothing more than print the word “hello” on the screen. Alternatively, the above program could be compiled using the following two commands.

Lab46:~$ g++ -c hello.C
Lab46:~$ g++ hello.o -o hello 

The end result is the same, but this two-step method first compiles hello.C into a machine code file named “hello.o” and then links hello.o with some system libraries to produce the final program “hello”. In fact the first method also does this two-stage process of compiling and linking, but the stages are done transparently, and the intermediate file “hello.o” is deleted in the process.

If the source code is in several files, say “file1.C” and “file2.C”, then they can be compiled into an executable program named “myprog” using the following command:

Lab46:~$ g++ file1.C file2.C -o myprog 

The same result can be achieved using the following three commands:

Lab46:~$ g++ -c file1.C
Lab46:~$ g++ -c file2.C
Lab46:~$ g++ file1.o file2.o -o myprog 

The advantage of the second method is that it compiles each of the source files separately. If, for instance, the above commands were used to create “myprog”, and “file1.C” was subsequently modified, then the following commands would correctly update “myprog”.

Lab46:~$ g++ -c file1.C
Lab46:~$ g++ file1.o file2.o -o myprog 

Note that file2.C does not need to be recompiled, so the time required to rebuild myprog is shorter than if the first method for compiling myprog were used. When there are numerous source file, and a change is only made to one of them, the time savings can be significant. This process, though somewhat complicated, is generally handled automatically by a makefile.

The fact that the compiler gives warnings is very helpful in debugging code. The example below contains a common error, a missing semicolon.

1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7     cout << "Hello World!" << endl
8     return 0;
9 }

Attempting compilation will give you the following error.

Lab46:~$ g++ test1.cc -o test1
test1.cc: In function 'int main()':
test1.cc:8: error: expected `;' before 'return'

As you can see, the compiler points out that there is a missing semicolon in function main() at or around line 8 (errors can and do cascade down) before the return statement.

The corrected code is:

1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7     cout << "Hello World!" << endl;
8     return 0;
9 }

When this is now compiled, the compiler will execute and exit, without any resulting output.

Testing the newly compiled program results in this:

Lab46:~$ ./test1
Hello World!

Great success!