【C++ Primer Plus】第九章内存模型和名称空间

野性酷女 2023-09-25 21:04 100阅读 0赞

#### 文章目录 ####

*   *  9.1 单独编译
     *  9.2 存储持续性，作用域和链接性
     *   *  9.2.1 作用域和链接
         *  9.2.2 自动存储持续性
         *   *  9.2.2.1 自动变量和栈
             *  9.2.2.2 寄存器变量
         *  9.2.3 静态持续变量
         *   *  9.2.3.1 如何创建这三种静态持续变量？
         *  9.2.4 静态持续性，外部链接性
         *   *  9.2.4.1 单定义规则
         *  9.2.5 静态持续性，内部链接性。
         *  9.2.6 静态存储持续性，无链接性
         *  9.2.7 说明符和限定符
         *   *  cv-限定符
             *   *  const
                 *  volatile
             *  mutable
         *  9.2.8 函数和链接性
         *   *  C++在哪里查找函数
         *  9.2.9 语言链接性
         *  9.2.10 存储方案和动态分配
         *   *  new的高级用法--定位new运算符
     *  9.3 名称空间
     *   *  using声明和using编译指令
         *  名称空间及其前途
     *  9.4 总结

### 9.1 单独编译 ###

请不要将函数定义或变量声明放到头文件里。这样做对于简单的情况可能是可行的，但通常会引来麻烦。例如，如果在头文件包含一个函数定义，然后在其他两个文件（属于同一个程序）中包含该头文件，则同一个程序中将包含同一个函数的两个定义，除非函数是内联的，否则这将出错。下面列出了头文件中常包含的内容：

*  函数原型
 *  使用\#define或const定义的符号常量
 *  结构声明
 *  类声明
 *  模板声明
 *  内联函数

注意，在包含头文件时，我们使用“coordin.h”，而不是<coodin.h>。如果文件名包含在尖括号中，则C++编译器将在**存储标准头文件的主机系统的文件系统中**查找；但如果文件名包含在双引号中，则编译器将**首先查找当前的工作目录或源代码目录**（或其他目录，这取决于编译器）。如果没有在那里找到头文件，则将在标准位置查找。因此在包含自己的头文件时，**应使用引号而不是尖括号**。

**多个库的链接**

C++标准允许每个编译器设计人员以他认为合适的方式实现名称修饰，因此由不同编译器创建的二进制模块（对象代码文件）很可能无法正确地链接。也就是说，两个编译器将为同一个函数生成不同的修饰名称。名称的不同将使链接器无法将一个编译器生成的函数调用与另一个编译器生成的函数定义匹配。在链接编译模块时，请确保所有对象文件或库都是由同一个编译器生成的。如果有源代码，通常可以用自己的编译器重新编译源代码来消除链接错误。

### 9.2 存储持续性，作用域和链接性 ###

C++使用三种（在C++11中是四种）不同的方案来存储数据，这些方案的区别就在于数据保留在内存中的时间。

*  自动存储持续性：在函数定义中声明的变量（包括函数参数）的存储持续性为自动的。它们在程序开始执行其所属的函数或代码块时被创建，在执行完函数或代码块时，它们使用的内存被释放。C++有两种存储持续性为自动的变量。
 *  静态存储持续性：在函数定义外定义的变量和使用关键字static定义的变量的存储持续性都为静态。它们在程序整个运行过程中都存在。C++有3种存储持续性为静态的变量。
 *  线程存储持续性（C++11）：当前，多核处理器很常见，这些CPU可同时处理多个执行任务。这让程序能够将计算放在可并行处理的不同线程中。如果变量是使用关键字thread\_local声明的，则其生命周期与所属的线程一样长。本书不探讨并行编程。
 *  动态存储持续性：用new运算符分配的内存将一直存在，直到使用delete运算符将其释放或程序结束为止。这种内存的存储持续性为动态，有时被称为自由存储（free store）或堆（heap）。

#### 9.2.1 作用域和链接 ####

作用域描述了名称在文件（翻译单元）的多大范围内可见。链接性描述了名称如何在不同单元间共享。链接性为外部的名称可在文件间共享，链接性为内部的名称只能由一个文件中的函数共享。自动变量的名称没有链接性，因为它们不能共享。

代码块是由花括号括起的一系列语句。自动变量的作用域为局部，静态变量的作用域是全局还是局部取决于它是如何被定义的。在函数原型作用域中使用的名称只在包含参数列表的括号内可用（这就是为什么这些名称是什么以及是否出现都不重要的原因）。

C++函数的作用域可以是整个类或整个名称空间（包括全局的），但不能是局部的（即无法在函数中定义函数，但可以定义函数对象）。

#### 9.2.2 自动存储持续性 ####

在默认情况下，在函数中声明的函数参数和变量的存储持续性为自动，作用域为局部，没有链接性。另外，当程序开始执行这些变量所属的代码块时，将为其分配内存；当函数结束时，这些变量都将消失。如果在代码块中定义了变量，则该变量的存在时间和作用域将被限制在该代码块内。自动变量只在包含它们的函数或代码块中可见。

##### 9.2.2.1 自动变量和栈 #####

了解典型的C++编译器如何实现自动变量有助于更深入地了解自动变量。由于自动变量的数目随函数的开始和结束而增减，因此程序必须在运行时对自动变量进行管理。

常用的方法是留出一段内存，并将其视为栈，以管理变量的增减。之所以被称为栈，是由于新数据被象征性地  
放在原有数据的上面（也就是说，在相邻的内存单元中，而不是在同一个内存单元中），当程序使用完后，将其从栈中删除。栈的默认长度取决于实现，但编译器通常提供改变栈长度的选项。程序使用两个指针来跟踪栈，一个指针指向栈底——栈的开始位置，另一个指针指向堆顶——下一个可用内存单元。当函数被调用时，其自动变量将被加入到栈中，栈顶指针指向变量后面的下一个可用的内存单元。函数结束时，栈顶指针被重置为函数被调用前的值，从而释放新变量使用的内存。

栈是LIFO（后进先出）的，即最后加入到栈中的变量首先被弹出。这种设计简化了参数传递。函数调用将其参数的值放在栈顶，然后重新设置栈顶指针。被调用的函数根据其形参描述来确定每个参数的地址。

##### 9.2.2.2 寄存器变量 #####

关键字register最初是由C语言引入的，它建议编译器使用CPU寄存器来存储自动变量：

其目的在于访问变量的速度。

在C++11之前，这个关键字在C++中的用法始终未变，只是随着硬件和编译器变得越来越复杂，这种提示表明变量用得很多，编译器可对其做特殊处理。

在C++11中，这种提示作用也失去了，关键字register只是显式地指出变量是自动的。鉴于关键字register只能用于原本就是自动的变量，使用它的唯一原因是，指出程序员想使用一个自动变量，这个变量的名称可能与外部变量相同。这与auto以前的用途完全相同。然而，保留关键字register的重要原因是，避免使用了该关键字的现有代码非法。

#### 9.2.3 静态持续变量 ####

和C语言一样，C++也为静态存储持续性变量提供了3种链接性：外部链接性（可在其他文件中访问）、内部链接性（只能在当前文件中访问）和无链接性（只能在当前函数或代码块中访问）。这3种链接性都在整个程序执行期间存在，与自动变量相比，它们的寿命更长。由于静态变量的数目在程序运行期间是不变的，因此程序不需要使用特殊的装置（如栈）来管理它们。编译器将分配固定的内存块来存储所有的静态变量，这些变量在整个程序执行期间一直存在。另外，如果没有显式地初始化静态变量，编译器将把它设置为0。在默认情况下，静态数组和结构将每个元素或成员的所有位都设置为0。

##### 9.2.3.1 如何创建这三种静态持续变量？ #####

*  要想创建链接性为外部的静态持续变量，必须在代码块的外面声明它；
 *  要创建链接性为内部的静态持续变量，必须在代码块的外面声明它，并使用static限定符；
 *  要创建没有链接性的静态持续变量，必须在代码块内声明它，并使用static限定符。

下面的代码片段说明这3种变量：

int global = 1000;  // 外部的静态持续变量
    static int one_file = 50;// 内部的静态持续变量
    int main(){
        ...
    }
    void funct1(int n){
        static int count = 0;//没有链接性的静态持续变量
        int llama = 0;
    }
    void funct2(int q){
        ...
    }

正如前面指出的，所有静态持续变量在整个程序执行期间都存在。

在funct1( )中声明的变量count的作用域为局部，没有链接性，这意味着只能在funct1( )函数中使用它，就像自动变量llama一样。然而，与llama不同的是，即使在funct1( )函数没有被执行时，count也留在内存中。

global和one\_file的作用域都为整个文件，即在从声明位置到文件结尾的范围内都可以被使用。具体地说，可以在main( )、funct1( )和funct2( )中使用它们。由于one\_file的链接性为内部，因此只能在包含上述代码的文件中使用它；由于global的链接性为外部，因此可以在程序的其他文件中使用它。

所有的静态持续变量都有下述初始化特征：未被初始化的静态变量的所有位都被设置为0。这种变量被称为零初始化。

表9.1指出了关键字static的两种用法，但含义有些不同：用于局部声明，以指出变量是无链接性的静态变量时，static表示的是存储持续性；而用于代码块外的声明时，static表示内部链接性，而变量已经是静态持续性了。有人称之为关键字重载，即关键字的含义取决于上下文。

<table> 
 <thead> 
  <tr> 
   <th>存储描述</th> 
   <th>持续性</th> 
   <th>作用域</th> 
   <th>链接性</th> 
   <th>如何声明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>自动</td> 
   <td>自动</td> 
   <td>代码块</td> 
   <td>无</td> 
   <td>在代码中</td> 
  </tr> 
  <tr> 
   <td>寄存器</td> 
   <td>自动</td> 
   <td>代码块</td> 
   <td>无</td> 
   <td>在代码中，使用关键字register</td> 
  </tr> 
  <tr> 
   <td>静态，无链接性</td> 
   <td>静态</td> 
   <td>代码块</td> 
   <td>无</td> 
   <td>在代码中，使用关键字static</td> 
  </tr> 
  <tr> 
   <td>静态，外部链接性</td> 
   <td>静态</td> 
   <td>文件</td> 
   <td>外部</td> 
   <td>不在任何函数中</td> 
  </tr> 
  <tr> 
   <td>静态，内部链接性</td> 
   <td>静态</td> 
   <td>文件</td> 
   <td>内部</td> 
   <td>不在任何函数中，使用关键字static</td> 
  </tr> 
 </tbody> 
</table>

静态变量的初始化

除默认的零初始化外，还可对静态变量进行常量表达式初始化和动态初始化。

零初始化和常量表达式初始化被统称为静态初始化，这意味着在编译器处理文件（翻译单元）时初始化变量。动态初始化意味着变量将在编译后初始化。

初始化形式由什么因素决定呢？首先，所有静态变量都被零初始化，而不管程序员是否显式地初始化了它。接下来，如果使用常量表达式初始化了变量，且编译器仅根据文件内容（包括被包含的头文件）就可计算表达式，编译器将执行常量表达式初始化。必要时，编译器将执行简单计算。如果没有足够的信息，变量将被动态初始化

int x;
    int y = 5;
    long z = 13*13;
    const double pi = 4.0 * atan(1.0);

首先，x、y、z和pi被零初始化。然后，编译器计算常量表达式，并将y和z分别初始化为5和169。但要初始化pi，必须调用函数atan()，这需要等到该函数被链接且程序执行时。

常量表达式并非只能是使用字面常量的算术表达式。例如，它还可使用sizeof运算符：

int enough = 2*sizeof(long)+1;

C++11新增了关键字constexpr，这增加了创建常量表达式的方式。

#### 9.2.4 静态持续性，外部链接性 ####

链接性为外部的变量通常简称为外部变量，它们的存储持续性为静态，作用域为整个文件。外部变量是在函数外部定义的，因此对所有函数而言都是外部的。可以在文件中位于外部变量定义后面的任何函数中使用它，因此外部变量也称全局变量（相对于局部的自动变量）。

##### 9.2.4.1 单定义规则 #####

变量只能有一次定义。为满足这种需求，C++提供了两种变量声明。一种是定义声明，简称为定义，它给  
变量分配存储空间；另一种是引用声明，或简称为声明，它不给变量分配存储空间，因为它引用已有的变量。

引用声明使用关键字extern，且不进行初始化；否则，声明为定义，导致分配存储空间。如果要在多个文件中使用外部变量，只需在一个文件中包含该变量的定义（单定义规则），但在使用该变量的其他所有文件中，都必须使用关键字extern声明它：

//file01.cpp
    extern int cats = 20;
    int dogs = 22;
    int fleas;
    
    //file02.cpp
    extern int cats;
    extern int dogs;
    
    //file03.cpp
    extern int cats;
    extern int dogs;
    extern int fleas;

在这里，所有文件都使用了在file01.cpp中定义的变量cats和dogs，但file02.cpp没有重新声明变量fleas，因此无法访问它。在文件file01.cpp中，关键字extern并非必不可少的，因为即使省略它，效果也相同

![在这里插入图片描述][d054dd85a6414c809e5f651f11f8ea71.png]

C++比C语言更进了一步——它提供了作用域解析运算符（::）。放在变量名前面时，该运算符表示使用变量的全局版本。既然可以选择使用全局变量或局部变量，那么到底应使用哪种呢？首先，全局变量很有吸引力——因为所有的函数能访问全局变量，因此不用传递参数。但易于访问的代价很大——程序不可靠.程序越能避免对数据进行不必要的访问，就越能保持数据的完整性。通常情况下，应使用局部变量，应在需要知晓时才传递数据，而不应不加区分地使用全局变量来使数据可用，OOP在数据隔离方面又向前迈进了一步。

#### 9.2.5 静态持续性，内部链接性。 ####

将static限定符用于作用域为整个文件的变量时，该变量的链接性将为内部的。在多文件程序中，内部链接性和外部链接性之间的差别很有意义。链接性为内部的变量只能在其所属的文件中使用；但常规外部变量都具有外部链接性，即可以在其他文件中使用

如果要在其他文件中使用相同的名称来表示其他变量，该如何办呢？只需省略关键字extern即可吗？

//file1
    int errors = 20;
    ...
    //file2
    int errors = 5;
    void froobish(){
        cout<<errors<<endl;
    }

这种做法将失败，因为它违反了单定义规则。file2中的定义试图创建一个外部变量，因此程序将包含errors的两个定义，这是错误的。

但如果文件定义了一个静态外部变量，其名称与另一个文件中声明的常规外部变量相同，则在该文件中，静态变量将隐藏常规外部变量：

//file1
    int errors = 20;
    ...
    //file2
    static int errors = 5;
    void froobish(){
        cout<<errors<<endl;
    }

可使用外部变量在多文件程序的不同部分之间共享数据；可使用链接性为内部的静态变量在同一个文件中的多个函数之间共享数据（名称空间提供了另外一种共享数据的方法）。另外，如果将作用域为整个文件的变量变为静态的，就不必担心其名称与其他文件中的作用域为整个文件的变量发生冲突。

#### 9.2.6 静态存储持续性，无链接性 ####

至此，介绍了链接性分别为内部和外部、作用域为整个文件的变量。接下来介绍静态持续家族中的第三个成员——无链接性的局部变量。这种变量是这样创建的，将static限定符用于在代码块中定义的变量。在代码块中使用static时，将导致局部变量的存储持续性为静态的。这意味着虽然该变量只在该代码块中可用，但它在该代码块不处于活动状态时仍然存在。因此在两次函数调用之间，静态局部变量的值将保持不变。（静态变量适用于再生——可以用它们将瑞士银行的秘密账号传递到下一个要去的地方）。另外，如果初始化了静态局部变量，则程序只在启动时进行一次初始化。以后再调用函数时，将不会像自动变量那样再次被初始化。

#include <iostream>
    using namespace std;
    const int ArSize = 10;
    void strcount(const char * str);
    int main(){
    	char input[ArSize];
    	char next;
    	
    	cout<<"Enter a line:"<<endl;
    	cin.get(input,ArSize);
    	while(cin){
    		cin.get(next);
    		while(next != '\n'){
    			cin.get(next);
    		}
    		
    		cout<<"Enter next line:"<<endl;
    	}
    	return 0;
    }

该程序演示了一种处理行输入可能长于目标数组的方法。本书前面讲过，方法cin.get(input, ArSize)将一直读取输入，直到到达行尾或读取了ArSize-1个字符为止。它把换行符留在输入队列中。该程序使用cin.get(next)读取行输入后的字符。如果next是换行符，则说明cin.get(input, ArSize)读取了整行；否则说明行中还有字符没有被读取。随后，程序使用一个循环来丢弃余下的字符，不过读者可以修改代码，让下一轮输入读取行中余下的字符。该程序还利用了这样一个事实，即试图使用get(char \*, int)读取空行将导致cin为false。

#### 9.2.7 说明符和限定符 ####

有些被称为存储说明符或cv-限定符的C++关键字提供了其他有关存储的信息。下面是存储说明符：

*  auto（在C++11中不再是说明符）；
 *  register；
 *  static；
 *  extern；
 *  thread\_local（C++11新增的）；
 *  mutable。

在同一个声明中不能使用多个说明符，但thread\_local除外，它可与static或extern结合使用。

前面讲过，在C++11之前，可以在声明中使用关键字auto指出变量为自动变量；但在C++11中，auto用于自动类型推断。

关键字register用于在声明中指示寄存器存储，而在C++11中，它只是显式地指出变量是自动的。

关键字static被用在作用域为整个文件的声明中时，表示内部链接性；被用于局部声明中，表示局部变量的存储持续性为静态的。

关键字extern表明是引用声明，即声明引用在其他地方定义的变量。

关键字thread\_local指出变量的持续性与其所属线程的持续性相同。thread\_local变量之于线程，犹如常规静态变量之于整个程序。

关键字mutable的含义将根据const来解释，因此先来介绍cv-限定符，然后再解释它。

##### cv-限定符 #####

下面就是cv限定符：

*  const；
 *  volatile。

###### const ######

内存被初始化后，程序便不能再对它进行修改。const限定符对默认存储类型稍有影响。在默认情况下全局变量的链接性为外部的，但const全局变量的链接性为内部的。也就是说，在C++看来，全局const定义就像使用了static说明符一样。

const int fingers = 10;
    int main(void){}

假设将一组常量放在头文件中，并在同一个程序的多个文件中使用该头文件。那么，预处理器将头文件的内容包含到每个源文件中后，所有的源文件都将包含类似下面这样的定义：

const int fingers = 10;
    const char* warning = "Wak";

如果全局const声明的链接性像常规变量那样是外部的，则根据单定义规则，这将出错。也就是说，只能有一个文件可以包含前面的声明，而其他文件必须使用extern关键字来提供引用声明。另外，只有未使用extern关键字的声明才能进行初始化:

extern const int fingers;
    extern const char * warning;

因此，需要为某个文件使用一组定义，而其他文件使用另一组声明。然而，由于外部定义的const数据的链接性为内部的，因此可以在所有文件中使用相同的声明。

内部链接性还意味着，每个文件都有自己的一组常量，而不是所有文件共享一组常量。每个定义都是其所属文件私有的，这就是能够将常量定义放在头文件中的原因。如果出于某种原因，程序员希望某个常量的链接性为外部的，则可以使用extern关键字来覆盖默认的内部链接性：

extern const int states = 50;

###### volatile ######

关键字volatile表明，即使程序代码没有对内存单元进行修改，其值也可能发生变化。听起来似乎很神秘，实际上并非如此。例如，可以将一个指针指向某个硬件位置，其中包含了来自串行端口的时间或信息。在这种情况下，硬件（而不是程序）可能修改其中的内容。或者两个程序可能互相影响，共享数据。

该关键字的作用是为了改善编译器的优化能力。例如，假设编译器发现，程序在几条语句中两次使用了某个变量的值，则编译器可能不是让程序查找这个值两次，而是将这个值缓存到寄存器中。这种优化假设变量的值在这两次使用之间不会变化。如果不将变量声明为volatile，则编译器将进行这种优化；将变量声明为volatile，相当于告诉编译器，不要进行这种优化。

在这种情况下，必须在所有使用该常量的文件中使用extern关键字来声明它。这与常规外部变量不同，定义常规外部变量时，不必使用extern关键字，但在使用该变量的其他文件中必须使用extern。然而，请记住，鉴于单个const在多个文件之间共享，因此只有一个文件可对其进行初始化

##### mutable #####

可以用它来指出，即使结构（或类）变量为const，其某个成员也可以被修改。例如，请看下面的代码：

struct data{
        char name[30];
        mutable int accesses;
    }
    const data veep = {"Claybourne",0};
    strcpy(veep.name,"Joye Joux");//不允许这样做
    veep.accesses++;//这样是允许的

veep的const限定符禁止程序修改veep的成员，但access成员的mutable说明符使得access不受这种限制。

#### 9.2.8 函数和链接性 ####

和变量一样，函数也有链接性，C++不允许在一个函数中定义另外一个函数，因此所有函数的存储持续性都自动为静态的，即在整个程序执行期间都一直存在。在默认情况下，函数的链接性为外部的，即可以在文件间共享。实际上，可以在函数原型中使用关键字extern来指出函数是在另一个文件中定义的，不过这是可选的（要让程序在另一个文件中查找函数，该文件必须作为程序的组成部分被编译，或者是由链接程序搜索的库文件）。还可以使用关键字static将函数的链接性设置为内部的，使之只能在一个文件中使用。必须同时在原型和函数定义中使用该关键字：

static int private(double x);
    static int private(double x){}

这意味着该函数只在这个文件中可见，还意味着可以在其他文件中定义同名的的函数。和变量一样，在定义静态函数的文件中，**静态函数将覆盖外部定义，因此即使在外部定义了同名的函数，该文件仍将使用静态函数。**

单定义规则也适用于非内联函数，因此对于每个非内联函数，程序只能包含一个定义。对于链接性为外部的函数来说，这意味着在多文件程序中，只能有一个文件（该文件可能是库文件，而不是您提供的）包含该函数的定义，但使用该函数的每个文件都应包含其函数原型。内联函数不受这项规则的约束，这允许程序员能够将内联函数的定义放在头文件中。这样，包含了头文件的每个文件都有内联函数的定义。然而，C++要求同一个函数的所有内联定义都必须相同。

##### C++在哪里查找函数 #####

假设在程序的某个文件中调用一个函数，C++将到哪里去寻找该函数的定义呢？如果该文件中的函数原型指出该函数是静态的，则编译器将只在该文件中查找函数定义；否则，编译器（包括链接程序）将在所有的程序文件中查找。如果找到两个定义，编译器将发出错误消息，因为每个外部函数只能有一个定义。如果在程序文件中没有找到，编译器将在库中搜索。这意味着如果定义了一个与库函数同名的函数，编译器将使用程序员定义的版本，而不  
是库函数（然而，C++保留了标准库函数的名称，即程序员不应使用它们）。有些编译器-链接程序要求显式地指出要搜索哪些库。

#### 9.2.9 语言链接性 ####

首先介绍一些背景知识。链接程序要求每个不同的函数都有不同的符号名。在C语言中，一个名称只对应一个函数，因此这很容易实现。为满足内部需要，C语言编译器可能将spiff这样的函数名翻译为\_spiff。这种方法被称为C语言链接性（C language linkage）。

但在C++中，同一个名称可能对应多个函数(C++函数重载)，必须将这些函数翻译为不同的符号名称。因此，C++编译器执行名称矫正或名称修饰，为重载函数生成不同的符号名称。例如，可能将spiff（int）转换为\_spoff\_i，而将spiff（double，double）转换为\_spiff\_d\_d。这种方法被称为C++语言链接。

链接程序寻找与C++函数调用匹配的函数时，使用的方法与C语言不同。为解决这种问题，可以用函数原型来指出要使用的约定：

extern "C" void spiff(int);// use C protocol for name look-up
    extern  void spoff(int);   //use C++ protocol for name look-up
    extern "C++" void spaff(int);//use C++ protocol for name look-up

第一个原型使用C语言链接性；而后面的两个使用C++语言链接性。第二个原型是通过默认方式指出这一点的，而第三个显式地指出了这一点。

#### 9.2.10 存储方案和动态分配 ####

前面介绍的C++为变量分配内存的方案并不适用于C++运算符new（C函数malloc()）分配的内存，这种内存被称为动态内存。动态内存由运算符new和delete控制，而不是由作用域和链接性规则控制。因此，可以在一个函数中分配动态内存，而在另一个函数中将其释放。与自动内存不同，动态内存不是LIFO，其分配和释放顺序要取决于new和delete在何时以何种方式被使用。通常，编译器使用三块独立的内存：一块用于静态变量（可能再细分），一块用于自动变量，另外一块用于动态存储。

虽然存储方案概念不适用于动态内存，但适用于用来跟踪动态内存的自动和静态指针变量：

float * p_free = new float[20];

由new分配的80个字节（假设float为4个字节）的内存将一直保留在内存中，直到使用delete运算符将其释放。但当包含该声明的语句块执行完毕时，p\_fees指针将消失。如果希望另一个函数能够使用这80个字节中的内容，则必须将其地址传递或返回给该函数。另一方面，如果将p\_fees的链接性声明为外部的，则文件中位于该声明后面的所有函数都可以使用它。另外，通过在另一个文件中使用下述声明，便可在其中使用该指针：

extern float * p_fees;

在程序结束时，由new分配的内存通常都将被释放，不过情况也并不总是这样。例如，在不那么健壮的操作系统中，在某些情况下，请求大型内存块将导致该代码块在程序结束不会被自动释放。最佳的做法是，使用delete来释放new分配的内存。

使用new运算符初始化：

int *pi = new int(6);                    //C++98的做法：
    
    struct where{
        double X;
        double y;
        double z;
    }
    where * one = new where{2.5,5.3,7.2};      //C++11的做法
    int * ar = new int[4]{2,4,6,7};

new可能找不到请求的内存量。在最初的10年中，C++在这种情况下让new返回空指针，但现在将引发异常std::bad\_alloc。

**调用过程**

运算符new和new\[\]，delete和delete\[\]分别调用替换函数：

void * operator new(std::size_t);
    void * operator new[](std::size_t);
    //上面的函数被称为分配函数，它们位于全局名称空间中。
    void * operator delete(std::size_t);
    void * operator delete(std::size_t);

std::size\_t是一个typedef，对应于合适的整型。

int *pi = new int;//将被转换成下面的类型
    int *pi = new(sizeof(int));
    int *pa = new int[40];//将被转换成下面的类型
    int *pa = new (40 * sizeof(int));
    delete pi;//将被转换成下面的类型
    delete(pi);

正如上面提到的，使用运算符new的语句也可以包含初始值，因此，使用new运算符时，可能不仅仅是调用new()运算符。

有趣的是，C++将这些函数称为可替换的。这意味着如果您有足够的知识和意愿，可为new和delete提供替换函数，并根据需要对其进行定制。例如，可定义作用域为类的替换函数，并对其进行定制，以满足该类的内存分配需求。在代码中，仍将使用new运算符，但它将调用您定义的new()函数。

##### new的高级用法–定位new运算符 #####

通常，new负责在堆中找到一个足以能够满足要求的内存块。new运算符还有另一种变体，被称为定位new运算符，它让您能够指定要使用的位置。程序员可能使用这种特性来设置其内存管理规程、处理需要通过特定地址进行访问的硬件或在特定位置创建对象。

要使用定位new特性，首先需要包含头文件new，它提供了这种版本的new运算符的原型；然后将new运算符用于提供了所需地址的参数。除需要指定参数外，句法与常规new运算符相同。具体地说，使用定位new运算符时，变量后面可以有方括号，也可以没有。下面的代码段演示了new运算符的4种用法：

#include <new>
    struct chaff{
        char dross[20];
        int slag;
    }
    char buffer1[50];
    char buffer2[500];
    int main(){
        chaff *p1,*p2;
        int *p3,*p4;
        p1 = new chaff;             //place structure in heap;
        p3 = new int[20];           //place int array in heap;
        p2 = new (buffer1) chaff;   //place structure in buffer1;
        p4 = new (buffer2) int[20]; //place int array in buffer2;
    }

出于简化的目的，这个示例使用两个静态数组来为定位new运算符提供内存空间。因此，上述代码从buffer1中分配空间给结构chaff，从buffer2中分配空间给一个包含20个元素的int数组。

#include <iostream>
    #include <new>
    using namespace std;
    const int BUF = 512;
    const int N = 5;
    char buffer[BUF];
    
    int main(){
    	double *pd1,*pd2;
    	int i;
    	
    	cout<<"Calling new and placement new a fist time:"<<endl;
    	
    	pd1 = new double[N];
    	pd2 = new (buffer) double[N];
    	
    	for(i = 0;i < N; i++){
    		pd2[i] = pd1[i] = 1000 + 20.0 * i;
    	}
    	
    	cout<<"Memory addresser:"<<endl<<" heap:"<<pd1<<" static:"<<(void *)buffer<<endl;
    	
    	cout<<"Memory contents:"<<endl;
    	for(i = 0;i < N;i ++){
    		cout<< pd1[i]<<" at "<<&pd1[i]<<";";
    		cout<< pd2[i]<<" at "<<&pd2[i]<<endl;
    	}
    	
    	cout<<endl<<"Calling new and placement new a second time:"<<endl;
    	
    	double *pd3,*pd4;
    	pd3 = new double[N];
    	pd4 = new (buffer) double[N];
    	
    	for(i = 0;i < N;i++){
    		pd4[i] = pd3[i] = 1000 + 40.0 * i; 
    	}
    	
    	cout<<"Memory contents:"<<endl;
    	for(i = 0;i<N;i++){
    		cout<<pd3[i]<<" at "<<&pd3[i]<<";";
    		cout<<pd4[i]<<" at "<<&pd4[i]<<endl;
    	}
    	
    	cout<<endl<<"Calling new and placement new a third time:"<<endl;
    	delete [] pd1;
    	pd1 = new double[N];
    	pd2 = new ( buffer + N * sizeof(double) ) double[N];
    	for(i = 0; i < N; i++){
    		pd2[i] = pd1[i] = 1000+ 60.0*i;
    	}
    	
    	cout<<"Memory contents:\n";
    	
    	for(i = 0; i < N; i++){
    		cout<<pd1[i]<<" at "<<&pd1[i]<<";";
    		cout<<pd2[i]<<" at "<<&pd2[i]<<endl;
    	}
    	
    	delete [] pd1;
    	delete [] pd3;
    	return 0;
    }
    
    Calling new and placement new a fist time:
    Memory addresser:
     heap:0x1c1640 static:0x408040
    Memory contents:
    1000 at 0x1c1640;1000 at 0x408040
    1020 at 0x1c1648;1020 at 0x408048
    1040 at 0x1c1650;1040 at 0x408050
    1060 at 0x1c1658;1060 at 0x408058
    1080 at 0x1c1660;1080 at 0x408060
    
    Calling new and placement new a second time:
    Memory contents:
    1000 at 0x1c1670;1000 at 0x408040
    1040 at 0x1c1678;1040 at 0x408048
    1080 at 0x1c1680;1080 at 0x408050
    1120 at 0x1c1688;1120 at 0x408058
    1160 at 0x1c1690;1160 at 0x408060
    
    Calling new and placement new a third time:
    Memory contents:
    1000 at 0x1c1640;1000 at 0x408068
    1060 at 0x1c1648;1060 at 0x408070
    1120 at 0x1c1650;1120 at 0x408078
    1180 at 0x1c1658;1180 at 0x408080
    1240 at 0x1c1660;1240 at 0x408088
    
    --------------------------------

首先，定位new运算符确实将数组p2放在了数组buffer中;

其次，第二个定位new运算符分配与以前相同的内存块；

最后，程序没有使用delete来释放使用定位new运算符分配的内存。事实上，在这个例子中不能这样做，buffer指定的内存是静态内存，而delete只能用于这样的指针：指向常规new运算符分配的堆内存。也就是说，数组buffer位于delete的管辖区域之外。

如果buffer是使用常规new运算符创建的，便可以使用常规delete运算符来释放整个内存块。

定位new运算符的另一种用法是，将其与初始化结合使用，从而将信息放在特定的硬件地址处。您可能想知道定位new运算符的工作原理。基本上，它只是返回传递给它的地址，并将其强制转换为void \*，以便能够赋给任何指针类型。但这说的是默认定位new函数，C++允许程序员重载定位new函数。

定位new函数不可替换，但可重载。它至少需要接收两个参数，其中第一个总是std::size\_t，指定了请求的字节数。这样的重载函数都被称为定义new，即使额外的参数没有指定位置。

### 9.3 名称空间 ###

声明区域：声明区域是可以在其中进行声明的区域。

潜在作用域：变量的潜在作用域从声明点开始，到其声明区域的结尾。因此潜在作用域比声明区域小，这是由于变量必须定义后才能使用。

namespace Jack{}

名称空间可以是全局的，也可以位于另一个名称空间中，但不能位于代码块中。因此，在默认情况下，在名称空间中声明的名称的链接性为外部的（除非它引用了常量）。除了用户定义的名称空间外，还存在另一个名称空间——全局名称空间（global namespace）。它对应于文件级声明区域，因此前面所说的全局变量现在被描述为位于全局名称空间中。

需要有一种方法来访问给定名称空间中的名称。最简单的方法是，通过作用域解析运算符::。

#### using声明和using编译指令 ####

using声明使特定的标识符可用，using编译指令使整个名称空间可用。

using声明由被限定的名称和它前面的关键字using组成：

using Jill::fetch;//使用了这条语句后就可以用fetch代替Jill::fetch.
    using namespace Jill;//using声明使一个名称可用，而using编译指令使所有的名称都可用,
    //但是它们的使用增加了名称冲突的可能性。

使用using编译指令导入一个名称空间中所有的名称与使用多个using声明是不一样的，而更像是大量使用作用域解析运算符。使用using声明时，就好像声明了相应的名称一样。如果某个名称已经在函数中声明了，则不能用using声明导入相同的名称。然而，使用using编译指令时，将进行名称解析，就像在包含using声明和名称空间本身的最小声明区域中声明了名称一样。在下面的示例中，名称空间为全局的。如果使用using编译指令导入一个已经在函数中声明的名称，则局部名称将隐藏名称空间名，就像隐藏同名的全局变量一样。不过仍可以像下面的示例中那样使用作用域解析运算符：

namespace Jill{
        double bucket;
        double fetch;
        struct hill{};
    }
    char fetch;
    int main(){
        using namespace Jill;
        Hill Thrill;//可以，建立Jill：：Hill
        double watch = bucket(2);//use Jill::bucket;
        double fetch;//not an error,hides jill::fetch
        cin>>fetch;//local fetch
        cin>>::fetch;//global fetch
        cin>>Jill::fetch;//Jill::fetch
    }
    int foom(){
        Hill top;//不行
        Jill::Hill cerat;//可以
    }

假设名称空间和声明区域定义了相同的名称。如果试图使用using声明将名称空间的名称导入该声明区域，则这两个名称会发生冲突，从而出错。如果使用using编译指令将该名称空间的名称导入该声明区域，则局部版本将隐藏名称空间版本。

一般说来，使用using声明比使用using编译指令更安全，这是由于它只导入指定的名称。如果该名称与局部名称发生冲突，编译器将发出指示。using编译指令导入所有名称，包括可能并不需要的名称。如果与局部名称发生冲突，则局部名称将覆盖名称空间版本，而编译器并不会发出警告。

可以给名称空间创建别名：

namespace my_vary_favorite_things{...};
    namespace mvft = my_vary_favorite_things;

匿名命名空间

namespace{
        int ice;
        int bandycoot;
    }

在该名称空间中声明的名称的潜在作用域为：**从声明点到该声明区域末尾**。从这个方面看，它们与全局变量相似。然而，由于这种名称空间没有名称，因此不能显式地使用using编译指令或using声明来使它在其他位置都可用。具体地说，不能在未命名名称空间所属文件之外的其他文件中，使用该名称空间中的名称。这提供了链接性为内部的静态变量的替代品。例如:

static int counts;
    int other();
    int main(){
        ... 
    }
    int other(){ 
        ... 
    }
    采用命名空间的方法如下：
    namespace{
        int counts;
    } 
    int other();
    int main(){
        ... 
    }
    int other(){ 
        ... 
    }

#### 名称空间及其前途 ####

*  使用在已命名的名称空间中声明的变量，而不是使用外部全局变量。
 *  使用在已命名的名称空间中声明的变量，而不是使用静态全局变量。
 *  如果开发了一个函数库或类库，将其放在一个名称空间中。事实上，C++当前提倡将标准函数库放在名称空间std中，这种做法扩展到了来自C语言中的函数。例如，头文件math.h是与C语言兼容的，没有使用名称空间，但C++头文件cmath应将各种数学库函数放在名称空间std中。实际上，并非所有的编译器都完成了这种过渡。
 *  仅将编译指令using作为一种将旧代码转换为使用名称空间的权宜之计。
 *  不要在头文件中使用using编译指令。首先，这样做掩盖了要让哪些名称可用；另外，包含头文件的顺序可能影响程序的行为。如果非要使用编译指令using，应将其放在所有预处理器编译指令\#include之后。
 *  导入名称时，首选使用作用域解析运算符或using声明的方法。
 *  对于using声明，首选将其作用域设置为局部而不是全局。

#include<iostream>
    using namespace std;//相当于下列代码
    #include<iostream.h>

### 9.4 总结 ###

C++鼓励程序员在开发程序时使用多个文件。一种有效的组织策略是，使用头文件来定义用户类型，为操纵用户类型的函数提供函数原型；并将函数定义放在一个独立的源代码文件中。头文件和源代码文件一起定义和实现了用户定义的类型及其使用方式。最后，将main( )和其他使用这些函数的函数放在第三个文件中。

C++的存储方案决定了变量保留在内存中的时间（储存持续性）以及程序的哪一部分可以访问它（作用域和链接性）。自动变量是在代码块（如函数体或函数体中的代码块）中定义的变量，仅当程序执行到包含定义的代码块时，它们才存在，并且可见。自动变量可以通过使用存储类型说明符register或根本不使用说明符来声明，没有使用说明符时，变量将默认为自动的。register说明符提示编译器，该变量的使用频率很高，但C++11摒弃了这种用法。

静态变量在整个程序执行期间都存在。对于在函数外面定义的变量，其所属文件中位于该变量的定义后面的所有函数都可以使用它（文件作用域），并可在程序的其他文件中使用（外部链接性）。另一个文件要使用这种变量，必须使用extern关键字来声明它。对于文件间共享的变量，应在一个文件中包含其定义声明（无需使用extern，但如果同时进行初始化，也可使用它），并在其他文件中包含引用声明（使用extern且不初始化）。在函数的外面使用关键字static定义的变量的作用域为整个文件，但是不能用于其他文件（内部链接性）。在代码块中使用关键字static定义的变量被限制在该代码块内（局部作用域、无链接性），但在整个程序执行期间，它都一直存在并且保持原值。

在默认情况下，C++函数的链接性为外部，因此可在文件间共享；但使用关键字static限定的函数的链接性为内部的，被限制在定义它的文件中。

动态内存分配和释放是使用new和delete进行的，它使用自由存储区或堆来存储数据。调用new占用内存，而调用delete释放内存。程序使用指针来跟踪这些内存单元。

名称空间允许定义一个可在其中声明标识符的命名区域。这样做的目的是减少名称冲突，尤其当程序非常大，并使用多个厂商的代码时。可以通过使用作用域解析运算符、using声明或using编译指令，来使名称空间中的标识符可用。

[d054dd85a6414c809e5f651f11f8ea71.png]: https://img-blog.csdnimg.cn/d054dd85a6414c809e5f651f11f8ea71.png