- Values are represented
inside the computer using a
code
Example: Code to represent integer values
11111111 11111111 11111111 11111111 = -1 00000000 00000000 00000000 00000000 = 0 00000000 00000000 00000000 00000001 = 1
- Different type of
values use different codes
Example: Code to represent floating point values
11111111 11111111 11111111 11111111 = -NaN (not a number) 00000000 00000000 00000000 00000000 = 0 00000000 00000000 00000000 00000001 = 1.4013e-45
- Example Program:
(Demo above code)
- Prog that shows integer and float uses different encoding: click here
- Typing information is
necessary for a
compiler to:
- translate an expression correctly
Example:
(integer) 00000000 00000000 00000000 00000001 ( = 1) (integer) 00000000 00000000 00000000 00000001 ( = 1) + -------------------------------------------------------- sum is equal = 2
(integer) 00000000 00000000 00000000 00000001 ( = 1) (float) 00000000 00000000 00000000 00000001 ( = 1.4013e-45) + ------------------------------------------------------------------- sum is equal ~ 1The outcome of an expression (such as addition) depends on the encoding (type) !!!
- A variable declaration
is a program construct used to:
- provide:
- name and
- type
information to the compiler
(so that the compiler can translate an expression correctly)
- provide:
- A variable declaration
does not reserve memory
to store the variable
- The equivalent construct of a
declaration in Java
is the import statement:
import java-package; // Declare stuff
- A large program
is almost always
split into functions stored in
separate files
- It is thus quite common that:
- 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")
- Some variable is
defined
in one file (say "file1.C")
- Example:
// 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; // x is not defined !!! } - When we compile
the program files, the compiler
detects an error in the
second file :
- Error: x is not defined.
The C++ compiler cannot complete its job because it does NOT know the location, type and size of the variable
- Example Program:
(Demo above code)
- 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
- Many unexperienced programmers
"solve" the
separate compilation
problem by
defining the variable multiple times
- Example:
// file1.C #include <iostream.h> int x; // Definition 1 int main() { x = 1234; cout << x << endl; f(); cout << x << endl; }// file2.C #include <iostream.h> int x; <----- Definition 2 void f() { x = 9999; }
- The problem
with this solution is:
- It is
not a standard solution
to handle
declare a variable
- 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.
- It is
not a standard solution
to handle
declare a variable
- Example Program:
(Demo above code)
- The main prog file: click here
- The second prog file: click here
- CC -c separate2a.C
- CC -c separate2b.C
- CC -o separate separate2a.o separate2b.o
- g++ -c separate2a.C
- g++ -c separate2b.C
- g++ -o separate separate2a.o separate2b.o
- g++ will report an error
It will work when compile with the Solaris C++ compile : And it will fail to compile with the GNU C++ compile :
- Here is the synopsis
of our "2 program files" problem:
- 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.
- We need to
define
(reserve space and record its address, type and size)
a variable before using it
- The problem with separate compilation is:
-
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 }
- The solution is as follows:
- When we compile the (second) program file,
we pretend
to
define
a variable of a
given type
and given name at
a fictitious address location
- Later , when
combine the 2 program files, the compiler
will
replace
the fictitious address with the
actual address
obtained from the actual definition
The combining of two or more programs and resolving variable references is done by a linking loader
- When we compile the (second) program file,
we pretend
to
define
a variable of a
given type
and given name at
a fictitious address location
- This mechanism requires
that the name and
type of
each variable is known to the compiler.
That is why programming languages have variable declaration
- NOTE:
- In Java, when you import
a class,
all variables and methods
defined in that class
are declared
- In Java, you cannot
declare individual variables
and/or methods
The "unit" of declaration in Java is one class
- In C++, you can
declare one variable and
one function (method) at a time...
You can also a class in C++
- In Java, when you import
a class,
all variables and methods
defined in that class
are declared
- Variable definition
is the
creation (i.e., space reservation)
of a variable
based on its description (name and type)
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
- Variable declaration
is the
description of a variable
- provide name and
type information to the compile;
does not reserve memory space
Example variable DECLARATION:
extern int myVar; extern float yourVar;
- How to solve the two program file
problem in C/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() { extern int x; // Tells compiler that // x is an int x = 9999; // Compile knows what // code to use for 9999 }
- Example Program:
(Demo variable declaration)
- The main prog file: click here
- The second prog file: click here
- CC -c separate3a.C
- CC -c separate3b.C
- CC -o separate separate3a.o separate3b.o
- g++ -c separate3a.C
- g++ -c separate3b.C
- g++ -o separate separate3a.o separate3b.o
It will work when compile with the Solaris C++ compile : And it will also work to compile with the GNU C++ compile :
- NOTE:
- When we discuss function, we will
also encounter
the definition
and
the declaration
of functions.
- We will discuss the difference between the definition and declaration of function in some future webpage....
- When we discuss function, we will
also encounter
the definition
and
the declaration
of functions.
- It is common to put the
variable definitions
into one (or more)
header files :
// Header file vars.h int x; int y; ....The header file is then included at the start of each program file:
// Program file 1 #include "vars.h" ....
// Program file 2 #include "vars.h" ....
// Program file 3 #include "vars.h" ....
- This would result in:
// Program file 1 int x; int y; ....
// Program file 2 int x; int y; ....
// Program file 3 int x; int y; ....
- As you have seen above, this is
non-standard
and your program will not always work.
- A commonly used C/C++
programming trick
(one of the first trick of a C/C++ programmer)
is the
#define EXTERN trick
to
define/declare
variable in a
multi-file program
The trick is best example through an example...
- Example: #define EXTERN
trick.
- Write the header file as follows:
// Header file vars.h #ifndef EXTERN #define EXTERN extern #endif EXTERN int x; EXTERN int y; ....The #ifndef EXTERN C++ pre-processer directive will test if the name EXTERN has been defined
If the name EXTERN has not been defined, the #define EXTERN extern C++ pre-processer directive will be executed (and EXTERN will be defined to be extern)
Otherwise, the the #define EXTERN extern C++ pre-processer directive will be skipped
- The program files contains the following
#include statements:
// Program file 1 #define EXTERN #include "vars.h" .... main() ....
// Program file 2 #include "vars.h" ....
// Program file 3 #include "vars.h" ....
Notice that the program file containing the main() function must contain the: #define EXTERN statement
After pre-processing, we will have:
// Program file 1 int x; int y; .... main() ....
// Program file 2 extern int x; extern int y; ....
// Program file 3 extern int x; extern int y; ....
You can see that the variables are defined once (in the main file) and are declared in all other files
- Write the header file as follows:
- Example Program:
(Demo above code)
- Header file: click here
- Prog file 1 (Main): click here
- Prog file 2: click here
- Prog file 3: click here
- What to do:
- CC -P file1.C
- CC -P file2.C
- CC -P file2.C
Look inside the file file1.i, file2.i, and file3.i
- Prime directive:
- Every identifier
in a C++ program must be
defined
or
declared
before it can be used
- Identifiers are used to identify:
- variables (variable name)
- class (class name)
- functions (function name)
- This directive translates to:
- Every variable,
every class
and every function
in a C++ program must be
defined
or
declared
before it can be used
- Every variable,
every class
and every function
in a C++ program must be
defined
or
declared
before it can be used
This practice benefits the programmer because it can help the programmer remove many hard to find typing-errors
- Every identifier
in a C++ program must be
defined
or
declared
before it can be used
- This practice is also the case in programming languages
Java,
Pascal, Modula 2, Modula 3, Ada...
- Some programming language that is not so: Fortran 77, Basic (Beginner All-purpose Symbolic Instruction Code) (they are terrible languages)