Cpp Chapter 9: Memory Models and Namespaces Part1

9.1 Separate compilation

) C++ could compile multiple files separately and link them into the final executable program

) You can divide original program into three parts(three files):

　　1. A header file that contains structure declarations and prototypes for functions that use those structures

　　2. A source code file that contains the code for structure-related functions

　　3. A source code file that contains the code for calling those functions

) Common things in header files: function prototypes, symbolic constants, structure declarations, class declarations, template declarations, inline functions

) Use #include "coordin.h" instead of #include <cooridn.h> while using user-defined header files. If a file name is enclosed in <>, C++ will look for the place for those standard header files. If a file is enclosed in "", C++ will first look for it at the current workspace, then the standard location

) In order to prevent multiple inclusion of a single header file, C++ develops this mechanism:

#ifndef COORDIN_H_
#define COORDIN_H_
// place header file content
#endif

Line 1 detects whether file "coordin.h" is already included or not, if so, it the content between #ifndef and #endif will be compiled. Line 2 marks the inclusion of file "coordin.h", so next time trying to include coordin.h will be ignored.

Here's an example of three separate files tring to convert rectangle to polar coordinates:

// coordin.h -- structure templates and function prototypes
#ifndef COORDIN_H_INCLUDED
#define COORDIN_H_INCLUDED

struct polar
{
    double distance;
    double angle;
};

struct rect
{
    double x;
    double y;
};

polar rect_to_polar(rect xypos);
void show_polar(polar dapos);

#endif // COORDIN_H_INCLUDED

// file1.cpp -- example of a three-file program
#include <iostream>
#include "coordin.h"
using namespace std;
int main()
{
    rect rplace;
    polar pplace;
    cout << "Enter the x and y values ";
    while (cin >> rplace.x >> rplace.y)
    {
        pplace = rect_to_polar(rplace);
        show_polar(pplace);
        cout << "Next two numbers (q to quit): ";
    }
    cout << "Bye!\n";
    return 0;
}

// file2.cpp -- contains function called in file1.cpp
#include <iostream>
#include <cmath>
#include "coordin.h" // structure templates and function prototypes

polar rect_to_polar(rect xypos)
{
    using namespace std;
    polar answer;

    answer.distance = sqrt(xypos.x * xypos.x + xypos.y * xypos.y);
    answer.angle = atan2(xypos.y, xypos.x);
    return answer;
}

void show_polar(polar dapos)
{
    using namespace std;
    const double Rad_to_deg = 57.29577951;
    cout << "distance = " << dapos.distance << ", angle = " << dapos.angle * Rad_to_deg <<" degrees\n";
}

As illustrated previously, coordin.h contains structure declarations and function prototypes. file1.cpp contains code using those functions. file2.cpp contains code defining those functions.

) C++ standard uses the word "translation unit" for file.

) In Code::Blocks, you create a project and add header files and source code files to the project, thus you could compile multiple files together and generate executable program.

9.2 Storage Duration, Scope, and Linkage

) Review: three schemes for storing data:

　　1. Automatic storage duration: variables defined within a function or a block, which are created when the program enters the block and freed when the program goes out.

　　2. Static storage duration: variables defined outside a function or with keyword static. They persist for the entire time a program is running.

　　3. Dynamic storage duration: memory allocated by new operator and deleted by delete operator. Sometimes termed free store or heap.

9.2.1 Scope and Linkage

) Scope: how widely visible a name is in a file

　　1. local scope: known only within the block it is defined

　　2. global scope: known throughout the file after the point it is defined

　　3. function prototype scope, class scope, namespac scope

) Linkage: how a name can be shared in different translation units

　　1. external linkage: can be shared across files

　　2. internal linkage: can be shared by functions within a single file

　　Note: automatic variables have no linkage

9.2.2 Automatic Storage Duration

) Functions parameters and variables declared in a function have automatic storage duration, local scope and no linkage by default. 

) If you define a variable inside a block, the variable's persistence and scope are confined to that block.

) If you have two same-name variables with one in outer block and one in inner block, the new definition hides the prior definition, meaning that the old definition is temporarily out of scope.

Here is an example of sharing-name variables:

// autoscp.cpp -- illustrating scope of automatic variables
#include <iostream>
void oil(int x);
int main()
{
    using namespace std;
    int texas = 31;
    int year = 2011;
    cout << "In main(), texas = " << texas << ", &texas = " << &texas << endl;
    cout << "In main(), year = " << year << ", &year = " << &year << endl;
    oil(texas);
    cout << "In main(), texas = " << texas << ", &texas = " << &texas << endl;
    cout << "In main(), year = " << year << ", &year = " << &year << endl;
    return 0;
}

void oil(int x)
{
    using namespace std;
    int texas = 5;
    cout << "In oil(), texas = " << texas << ", &texas = " << &texas << endl;
    cout << "In oil(), x = " << x << ", &x = " << &x << endl;
    {
        int texas = 113;
        cout << "In block, texas = " << texas << ", &texas = " << &texas << endl;
        cout << "In block, x = " << x << ", &x = " << &x << endl;
    }
    cout << "Post-block texas = " << texas << ", &texas = " << &texas << endl;
}

) The program uses a stack to store automatic variables by keeping track with two pointers, one to the base and one to the top(next insertion location). A stack is a LIFO design, meaning that the last variable added to the stack is the first to go.

9.2.3 Static Duration Variables

) To store static duration variables, the compiler allocates a fixed block of memory to hold the static variables, instead of using a special device such as a stack.

) If you don't explicitly initialize a static variable, the compiler sets it to 0.

) The five kinds of variable storage:

Storage Description	Duration	Scope	Linkage	How Declared
Automatic	Automatic	Block	None	In a block
Register	Automatic	Block	None	In a block with the keyword register
Static with no linkage	Static	Block	None	In a block with keyword static
Static with internal linkage	Static	File	Internal	Outside all functions
Static with external linkage	Static	File	External	Outside all functions with the keyword static

Duration: （automatic/static) the time that the variable exists before being freed. Automatic means freed outside the block, static means exist all through the program execution.

Scope: (block/file) the range that the variable could be accessed. Block means only accessed within the block it is declared, file means accessable throughout the file.

Linkage: (none/internal/external) the availability of variable in different files or units. None means only accessed within block, internal means accessed within file, external means accessible across files.

Here's an example illustrating these storage patterns:

int global = 100; // static duration, external linkage
static int one_file = 50; // static duration, internal linkage
void funct1(int n)
{
    static int count = 0; // static duration, none linkage
    int llama = 0; // automatic duration, none linkage
}

) Initializing Static variables:

　　1. zero-initialized: if you don't initialize the variable when declare it

　　2. constant expression initialization: initialize variable with a constant expression that the program could evaluate solely from the file contents(calculations allowed)

　　3. dynamic initialization: no enough information at the initializing time

Here's an example illustrating these initial patterns:

int x; // zero-initialization
int y = 5; // constant-expression initialization
int z = 13 * 13; // constant-expression initialization
const double pi = 4.0 * atan(1.0); // dynamic initialization