• Some variable is defined in one file (say "file1.C")

• And that variable is used in a function inside another file(s) (say "file2.C")

// file1.C #include <iostream.h> int x; int main() { x = 1234; cout << x << endl; f(); cout << x << endl; }

// file2.C #include <iostream.h> void f() { x = 9999; }

• Error: x is not defined.

  The compile cannot complete its job because it does NOT know the LOCATION, TYPE and SIZE about the variable

• The main prog file: click here
• The second prog file: click here

Compile with:

• CC -o separate separate1a.C separate1b.C

• Or (better) with:
  • CC -c separate1a.C
  • CC -c separate1b.C
  • CC -o separate separate1a.o separate1b.o

// file1.C #include <iostream.h> int x; int main() { x = 1234; cout << x << endl; f(); cout << x << endl; }

// file2.C #include <iostream.h> int x; void f() { x = 9999; }

• It is NOT a standard solution to handle separate compilation

• The solution may work when compiled with certain C++ compilers (one that assumes that when you define the same variable twice, the second definition refers to the first definition) while some other C++ compilers will abort the compilation.

• The main prog file: click here
• The second prog file: click here

It will work when compile with the Solaris C++ compile :

• CC -c separate2a.C
• CC -c separate2b.C
• CC -o separate separate2a.o separate2b.o

And it will fail to compile with the GNU C++ compile :

• g++ -c separate2a.C
• g++ -c separate2b.C
• g++ -o separate separate2a.o separate2b.o

• We need to define (reserve space and record its address, type and size) a variable before using it
• The compiler must have enough information (= address, type and size) to find a variable

• We cannot define the same variable MORE than once - some compiler does not like it.

The compiler does NOT have the address type and size information of the variable to do its work:

// file1.C #include <iostream.h> int x; int main() { x = 1234; cout << x << endl; f(); cout << x << endl; }

// file2.C #include <iostream.h> void f() { x = 9999; // Compiler does not know // address, type and size of x }

1. When we compile the (second) program file, we pretend to define a variable at the a fictitious address location

2. Later , when combine the 2 program files, the compiler will replace the fictitious address with the actual address obtained from the actual definition

Example variable definition:

int myVar; float yourVar;

• When C++ processes these variable definitions, the C++ compiler will reserve 4 bytes of memory space for each of these variables and record the location in memory

Example variable DECLARATION:

extern int myVar; extern float yourVar;

Important fact:

A declaration DOES NOT reserve any memory space (for the variable).

To provide the C/C++ compiler with the necessary information of the variable so that it CAN manipulate/use the variable)

• The keyword extern is used to declare a variable

Program file 1 int myVar; // DEFINITION float yourVar; // DEFINITION int main(int argc, char *argv[]) { .... }

Program file 2 extern int myVar; // DECLARATION extern float yourVar; // DECLARATION int AnotherFunction(....) { yourVar = myVar + sin(2.3); .... }

• The main prog file: click here
• The second prog file: click here

It will work when compile with the Solaris C++ compile :

• CC -c separate3a.C
• CC -c separate3b.C
• CC -o separate separate3a.o separate3b.o

And it will ALOS work to compile with the GNU C++ compile :

• g++ -c separate3a.C
• g++ -c separate3b.C
• g++ -o separate separate3a.o separate3b.o

• When we discuss function, we will encounter the definition and the declaration of function also.

• We will discuss the difference between the definition and declaration of function in some future webpage....

// Header file vars.h int x; int y; ....

// Program file 1 #include "vars.h" ....

// Program file 2 #include "vars.h" ....

• The variables are defined ONCE (inside a particular file, usually the file containing the main function)

• The variables are DECLARED in all other files

is to use the " #define EXTERN " trick

// Header file vars.h #ifndef EXTERN #define EXTERN extern #endif EXTERN int x; EXTERN int y; ....

// Program file 1 #define EXTERN #include "vars.h" .... main() ....

// Program file 2 #include "vars.h" ....

After preprocessing the EXTERN definition:

// Header file vars.h #ifndef EXTERN #define EXTERN extern #endif EXTERN int x; EXTERN int y; ....

// Program file 1 int x; int y; .... main() ....

// Program file 2 extern int x; extern int y; ....

This practice benefits the programmer because it can help the programmer remove many hard to find typing-errors