Memory Models and Namespaces

Separate Compilation of Programs

C++ allows and encourages you to locate component functions of a program in separate files.
Compile files separately and then link them into the final executable program.
header files:
- function prototypes
- symbolic constants defined using #define or const
- structure declarations: no variables created
- class declaration
- template declaration
- inline function
How to include header file ?
- use "coordin.h"
- NOT use <coordin.h>
- < >: C++ looks at system’s file system
- " ": C++ first looks at current working directory or source code director, after that, looks at system’s file.
Example of header file

#ifndef COORDIN_H_ // avoid multiple define
#define COORDIN_H_
...

#endif

Storage duration, Scope, and Linkage

Storage Duration

Storage categories affect how information can be shared across files.
C++ has 4 separate schemes for storing data:
- Automatic storage duration:
  - Variables declared inside a function definition.
  - Created when program execution enters the function or block.
  - Freed from memory when execution leaves the function or block.
- Static storage duration:
  - Variables defined outside a function definition or using the keyword static.
  - Persist for the entire time a program is running.
- Thread storage duration(under C++ 11):
  - Variables declared with the keyword thread_local.
  - Concurrent programming.
- Dynamic storage duration:
  - Memory allocated by the new operator persists until freed with delete operator or the program ends, whichever comes first.

Scope and Linkage

Automatic Storage Duration

Function parameters and variables declared inside a function have automatic storage duration by default.
Automatic storage duration means variables can only be seen inside a block or function.
- variables with the same name, the new definition inside the block will hide the prior definition.
- prior definition comes out after block or function ends.

int main()
{
    int a = 5; 
    {
        int b = 6; // b only valid in the block
        int a = 7; // a is 7 inside the block
    }
    ... // a is 5 and b does not exist
    ...
    return 0
}

To manage automatic variables, C++ uses the Stack, following last-in-first-out

Static Duration Variables

Three types:

external linkage

int global = 100;

internal linkage

static int one_file = 10;

no linkage

void func1(int n)
{
    static int count = 0;
}

Notes:
- global can be used in this file and other linked files.
- one_file can only be used in this file.
- count is defined inside the block and only used by func1. It is like automatic variables but it lasts in the memory longer.
All types of static duration variables last for the entire duration of the program.
Compiler does not need any special tools to manage static duration variables and just to use a fixed block of memory to hold all of them. If no explicit declaration, the compiler sets it to 0.
Initialization: zero-initialization by default.

#include <cmath>
int x; // zero-init
int y=5; // constant-expression init
long z=13*13; // constant-expression init
int w = 2 * sizeof(long) +1; // constant-expression init
const double pi = 4.0 * atan(1.0); // dynamic init, because of callin atan()

Static Duration, External Linkage

External Variable:
- variables with external linkage.
- defined above main() function or in header file.
- also called global variable, compared with automatic variables (local variable)
One Definition Rule
- there can be only one definition of a variable.
  - defining declaration
    - it causes storage for the variable to be allocated.
  - referencing declaration
    - not cause storage to be allocated and only refers to an existing variable.
- referencing declaration: extern:
```
double up;  // definition, up is 0
extern int blem;  // blem is defined elsewhere.
extern char gr = 'z';  // definition (initialized)
```

Static Duration, Internal Linkage

static modifier: file-scope variable with internal linkage.

// file 1
int error = 20; // external declaration

// file 2
static int error = 5; // known only in file 2

// wrong!!!
int error = 5; // violate one definition rule

Placement `new`: Dynamic Allocation

new & delete
The compiler uses 3 separate memory chunks:
- static variable
- automatic variable
- dynamic storage

Namespaces

Create Named Namespace

The same name defined in 2 namespace will not conflict with each other

namespace Jack {
    double pail; // variable declaration
    void fetch(); // function declaration
    int pal; // variable declaration
    struct Well {...}; // struct declaration
}

namespace Jill {
    double bucket (double n) {...}
    double fetch;
    int pal;
    struct Hill {...};
}

Name declared inside a namespace has external linkage by default.

`using` Declaration and `using` Directives

using Jill::fetch; // declaration
using namespace Jill; // directive

using declaration: make a single name available
using directives: make all names inside the namespace available.
It is safer to using declaration.

namespace Jill {
    double bucket(dounle n) {...}
    double fetch;
    struct Hill {...}
}

char fetch; // global namespace

int main() {
    using namespace Jill; // import all namespace names
    Hill Thrill; // create a type Jill::Hill
    double fetch; // hide Jill::fetch

    // local fetch
    cin >> fetch;

    // global fetch
    cin >> ::fetch;

    // Jill::fetch
    cin >> Jill::fetch;
}