- A C/C++ program consists of one or more functions
- A C/C++ program
must contain
the function:
-
int main(int argc, char *argv[])
- A C/C++ program begins its execution at
the function
main(argc, argv)
The main function usually call (invoke) other functions during the program execution.
- Example C++ program:
#include <iostream.h> // Header file containing useful definitions... int main(int argc, char *argv[]) { cout << "Hello World\n"; } -
Example Program:
(Demo First C++ program) ---
click here
- CC is the UNIX command used to compile C++ programs
- The general command syntax for CC is:
CC [options] ProgramFileName.C
- The program file name
MUST
end in ".C" or ".cc"
- The output of the compiler is a
computer executable program a.out
- To run the program, you type at the UNIX prompt:
a.out
- Many of these options can be combined.
- Examples:
CC -o myProg myProg.C Compile myProg.C into the executable output file myProg (instead of a.out CC -g -c myProg.C Produce relocatable object code with debug information
| Option | Meaning | Example | What does it do |
|---|---|---|---|
| -o FileName | Rename the executable output file | CC -o myProg myProg.C |
Compiler will rename executable output file from a.out to myProg |
| -g | Debug Mode | CC -g myProg.C |
Compiler will insert additional information in output a.out that can be use with a debugger (a tool to help programmers find errors in the program) |
| -c | Create relocatable object code | CC -c myProg.C |
Compiler will NOT produce a directly executable computer program, but
a program that can be combined with other "relocatable" codes
NOTE: use this option when your program consists of multiple text files |
| -lLibFile | Specify an additional library file | CC myProg.C -lmath |
Tell the C++ compiler to "link in" (include) functions from the "math" function library. The actual UNIX filename for a C++ library file "math" is "libmath.a" |
- Suppose your C/C++ program consists of
multiple files, e.g.:
myFile1.C and myFile1.C.
- The commands you need to produce the program called
myProg are:
CC -g -c myFile1.C // This command will produce the // relocatable object file myFile1.o // (which can be combined with other // relocatable object files CC -g -c myFile2.C // This command will produce another // relocatable object file myFile2.o // // We can now combine these files ! CC -o myProg myFile1.o myFile2.o
- NOTE:
Use the -g option when you are developing
your C/C++ program
Once you have tested your program thoroughly and made sure that it works, then recompile ALL the program files again, but WITHOUT the -g option:
CC -fast -c myFile1.C CC -fast -c myFile2.C CC -o myProg myFile1.o myFile2.o
- Before a C/C++ program is compiled, the text of the C/C++ program
is first pre-precessed by the C/C++ preprocessor
(this is another program that is automatically run
when you type "CC" to compile a C/C++ program)
- The C/C++ Pre-processor processes all
of the following # directives:
#define SYMBOL (Defines a symbol) #undef SYMBOL (Undefines a symbol) #include FILENAME (Insert file FILENAME in this spot) #if CONDITION (Skip to #endif if CONDITION is false) #ifdef SYMBOL (Skip to #endif if SYMBOL is NOT DEFINED) #ifndef SYMBOL (Skip to #endif if SYMBOL is DEFINED) #else (else part - used with #if...) #elif ("else if" - used with #if...) #endif (Used to mark the rang of #ifdef and #ifndef)
-
Example Program:
(Demo the #define directive) ---
click here
- To see the effect of #define, do the following:
- CC -P define.C
- Use an editor and look in the file define.i
- NOTE: if a symbol SYMBOL has already been defined previously, you must use #undef SYMBOL to undefine it before assigning it with a different value !
-
Example Program:
(Demo the #include directive) ---
click here
- To see the effect of #include, do the following:
- CC -P include.C
- Use an editor and look in the file include.i
- NOTE:
- #include "FILENAME"
will look for the include file
in the current working directory
- #include <FILENAME> will look for the include file in the system directories /usr/include/* and the directory paths specified using the -I (include) option
- #include "FILENAME"
will look for the include file
in the current working directory
- NOTE:
#include
can be NESTED
-
Example Program:
(Demo NESTED #include) ---
click here
- To see the effect of #include, do the following:
- CC -P NestedInclude.C
- Use an editor and look in the file NestedInclude.i
-
Example Program:
(Demo NESTED #include) ---
click here
- #ifdef and #ifndef are always paired with
#endif
- The enclosed text between (#ifdef and #endif)
or (#ifndef and #endif)
will be removed by the C/C++ pre-processor,
depending on whether the SYMBOL following
#ifdef and #ifndef is defined or not:
#ifdef SYMBOL Text between (#ifdef, #endif) is removed if SYMBOL is not defined [#else ... else part ] #endif
#ifndef SYMBOL Text between (#ifdef, #endif) is removed if SYMBOL is defined [#else ... else part ] #endif
-
Example Program:
(Demo the #ifdef and #ifndef directives) ---
click here
- To see the effect of #ifdef/#ifndef, do the following:
- Edit ifdef.C and define or remove #define FLAG
- CC -P ifdef.C
- Use an editor and look in the file ifdef.i
- #if if always paired with #endif
- The enclosed text between (#if and #endif)
will be removed by the C/C++ pre-processor,
if the condition specified by #if is not satisfied
#if CONDITION Text between (#ifdef, #endif) is removed if SYMBOL is not defined [#else ... else part ] #endif -
Example Program:
(Demo the #if preprocessor directive) ---
click here
- To see the effect of #ifdef/#ifndef, compile
the program using the -DFLAG
option:
- Try compile the program using CC -P -DFLAG=10 if.C first
- Look inside the file if.i
- Next, try define FLAG to something else, say -DFLAG=89
- Look inside the file if.i again and see the difference
- It is a common practice to put all programming parameters
and other constants in one (or a few) files
and #include these parameters at the beginning
of the program:
=========== Program.C: =========== #include "params.h" int main(int argc, char *argv[]) { ... } - When the project gets bigger and bigger, more and more
parameter files may be needed:
=========== Program.C: =========== #include "params1.h" // params1.h includes params0.h #include "params2.h" // params2.h includes params0.h int main(int argc, char *argv[]) { ... } - And because #include is nested, some parameter file
may include other parameter files.
For example: params1.h may include params3.h
- When the same parameter file is included more than
once (and defines the same symbols again),
the C/C++ preprocessor will complain....
- To prevent the definitions in a parameter file to
be processed more than once, use the following
#ifndef trick:
=========== Trick to prevent a parameter file to be process more than once =========== #ifndef _ThisParameterFileName_ #define _ThisParameterFileName_ .... put the parameter definitions here #endif
- How does this programming trick works:
- The FIRST time that the parameter file is processed,
the symbol _ThisParameterFileName_
is NOT defined.
- Therefore, the text in blue
will be processed
- Notice that processing the
text in blue
will define the symbol
_ThisParameterFileName_
- Suppose this parameter file is processed later
(by accident or because the programmer lost track
of which file was included where).
The SECOND time that the parameter file is processed, the symbol _ThisParameterFileName_ HAS ALREADY BEEN defined.
As a result, the entire file (till #endif) is skipped...
- The FIRST time that the parameter file is processed,
the symbol _ThisParameterFileName_
is NOT defined.
- Example Program:
(Demo include trick above)
- Main Prog file: click here
- params0.h file: click here
- params1.h Prog file: click here
- params2.h Prog file: click here
- Compile with: CC -P nested-include.C
Look inside "nested-include.i" to see the effect of the "ifdef"
- Try edit out the #ifdef and recompile and see the difference.