Anatomy of a C++ Program How the program is compiled and linked

Beginning

C++,the complete language, by Ivor Horton, Wrox Publishers. Object-oriented programming in C++ Robert Laford C++ How to program by Deitel & Deitel

 Prints

Welcome to C++

1 // Fig. 1.2: fig01_02.cpp

2 // A first program in C++

3 #include <iostream> 4 5 int main() 6 { 7 8 9 return 0; successfully 10 } // indicate that program ended cout << "Welcome to C++!\n";

1 2

// Fig. 1.2: fig01_02.cpp // A first program in C++

Comments Written between /* and */ or following a //. Improve program readability and do not cause the computer to perform any action. preprocessor directive

3 #include <iostream> 4 5 int main() 6 {

7 8 9 10 } return 0; cout << "Welcome to C++!\n";

Message to the C++ preprocessor. Lines beginning with # are preprocessor directives. #include <iostream> tells the preprocessor to include the contents of the file <iostream>, which C++ programs contain one or more functions, one of includes input/output which must be main operations (such as printing to the screen). Parenthesis are used to indicate a function

// indicate that program ended successfully

Welcome to C++!

Prints the string of characters contained between the an integer value. int means that main "returns" quotation marks. More in Chapter 3. return is a way to exit a function from a function. A left brace { begins the body The entire line, including cout, the << operator, theof every function and a right brace the semicolon string "Welcome to C++!\n" and } ends it. return 0, in this case, means that (;), is called the program terminated normally. a statement. All statements must end with a semicolon.

Cout
Output stream object Connected to the screen

<<
Stream insertion operator Value to the right of the operator (right operand) inserted into output stream (which is connected to the screen) cout << Welcome to C++!\n;

\
Escape character Indicates that a special character is to be output

Phases of C++ Programs: 1. Edit 2. Preprocess 3. Compile

Editor

Disk

Program is created in the editor and stored on disk. Preprocessor program processes the code. Compiler creates object code and stores it on disk. Linker links the object code with the libraries, creates a.out and stores it on disk

Preprocessor

Disk

Compiler

Disk

Linker

Disk
Primary Memory

Loader

4. Link
5. Load
Disk
.. .. ..

Loader puts program in memory.

6. Execute

Primary Memory

CPU

.. .. ..

CPU takes each instruction and executes it, possibly storing new data values as the program executes.

 Two

kinds of files that are used to hold your source code:

Header files Source files

Header

files are used to contain code that describes the data types that your program needs along with other sort of declarations. Referred as header files as they are at the beginning of the code.

Extensions :.h and .hxx

 Source

files, which have the filename extension .cpp

contain function definitions-the executable code for your program. any declaration or definition of data types.

Program Files
Prog1.cpp
#include <iostream> #include <first.h> #include <second.h> Function declarations Global variables definitions etc.

Header Files
Adds contents of standard header files

first.h
class(user.type) definitions Function declarations etc.

second.h
class(user.type) definitions Function declarations etc.

Prog2.cpp
#include <second.h> #include <flash.h> Function declarations Global variables definitions etc.

lash.h
class(user.type) definitions Function declarations etc.

 Creating

a program module that you can execute from your C++ source code is essentially a two-step process.

In first step, your compiler converts .cpp files to object files that contains machine code equivalent of the source file contents. In second step, the linker combines the object files produced by the compiler into a file containing the complete executable program.

10

11

 Compiling

process for source files has two main stages:

The first stage is preprocessor phase, which is carried out before the compilation phase proper. The preprocessor phase modifies the contents of the source file according to the preprocessor directives that you have placed in the file.

12

13

 The

output from the compiler of a give source code is machine code, it is quite long to execute. No connection will be established between one object file to another. Object files of source files contain references to functions or other name items. Similarly links to library functions will not yet be established.

14

 Linker

will combine the machine code from all object files and resolves any cross references between them. Integrates the code for any library functions that the object modules use. It is possible for links to be dynamic. In that case they are established when the program executes.

15

16

C++ has a set of basic types:

Various type operators for altering type meaning, including:

unsigned, long, short, const, static

This means we can have types such as long int and unsigned char.
17

When you declare a variable in C+ you ask the operating system for a piece of memory. You (can) give this piece of memory a name and you can store something in that piece of memory (for later use). Variables must be defined (i.e. storage set aside) exactly once. A variable name can be composed of letters, digits and underscore (_); a name must begin with a letter or underscore Variables are defined by prefixing a name with a type, and can optionally be initialised; for example: long int i = 28L;
18

 In

order to use a variable in C++, we must first declare it specifying which data type we want it to be.
syntax to declare a new variable is to write the specifier of the desired data type (like int, bool, float...) followed by a valid variable identifier. For example:

The

19

 These

are two valid declaration of variables.

The

first one declares a variable of type int with the identifier a. The second one declares a variable of type float with the identifier mynumber. Once declared, the variables a and mynumber can be used within the rest of their scope in the program.

20

 If

you are going to declare more than one variable of the same type, you can declare all of them in a single statement by separating their identifiers with commas. For example:
This

declares three variables (a, b and c), all of them of type int, and has exactly the same meaning as:

21

 The

integer data types char, short, long and int can be either signed or unsigned depending on the range of numbers needed to be represented. Signed types can represent both positive and negative values, whereas unsigned types can only represent positive values (and zero).

22

This can be specified by using either the specifier signed or the specifier unsigned before the type name. For example:

By default, if we do not specify either signed or unsigned most compiler settings will assume the type to be signed, therefore instead of the second declaration above we could have written:

with exactly the same meaning (with or without the keyword signed)

An exception to this general rule is the char type, which exists by itself and is considered a different fundamental data type from signed char and unsigned char, thought to store characters. You should use either signed or unsigned if you intend to store numerical values in a 23

and long can be used alone as type specifiers. In this case, they refer to their respective integer fundamental types:
short

short is equivalent to short int and long is equivalent to long int.

The

following two variable declarations are equivalent:

24

 Finally,

signed and unsigned may also be used as standalone type specifiers, meaning the same as signed int and unsigned int respectively.
following two declarations are equivalent:

The

25

26

 All

the variables that we intend to use in a program must have been declared with its type specifier in an earlier point in the code.

Like we did in the previous code at the beginning of the body of the function main when we declared that a, b, and result were of type int.

variable can be either of global or local scope.

27

global variable is a variable declared in the main body of the source code, outside all functions.
A local variable is one declared within the body of a function or a block.

28

29

Global variables can be referred from anywhere in the code, even inside functions, whenever it is after its declaration. The scope of local variables is limited to the block enclosed in braces ({}) where they are declared.

For example, if they are declared at the beginning of the body of a function (like in function main) their scope is between its declaration point and the end of that function. In the example above, this means that if another function existed in addition to main, the local variables declared in main could not be accessed from the other function and vice versa.
30