C++编程思想学习笔记---第十章 名字控制

第十章 名字控制

10.1 来自C语言中的静态元素

在C和C++的定义中，static都有两种基本含义：

1) 在固定的地址上进行存储分配，对象在静态区创建，而不是每次调用函数时在堆栈上产生。  ===> 生存期：在每次进入定义该变量的函数时

2) 如果static变量是定义在某个文件中，不在任何函数内，则它在该文件中是全局的。 ===>作用域：仅在该文件中可用（除非用extern在别的文件声明）

10.1.1 函数内部的静态变量

 C++允许在函数内部定义一个静态的內建类型变量，程序只在第一次进入时对其初始化，之后保持之前的值。

而如果没有为一个內建类型的静态变量提供一个初始值的话，编译器也会确保在程序开始时它被初始化为0，包括指针。

10.1.1.1 函数内部的静态对象

与上面的静态变量相比，不同的一点在于：零赋值只对內建类型有效，用户自定义类型必须用构造函数来初始化。因此，如果在定义一个静态对象时没有指定构造函数参数，这个类就必须有默认的构造函数。

#include<iostream>
using namespace std;

class X
{
	int i;
public:
	X(int ii = 0) : i(ii)
	{
		cout << "i = " << i << endl;
	}
	~X()
	{
		cout << "This is ~X()" << endl;
	}
};

void f()
{
	static X x1(5);
	static X x2;
}

int main()
{
	f();
}

上面成的打印为：

i = 5
i = 0
This is ~X()
This is ~X()

程序控制第一次转到对象的定义点时，才需要执行构造函数。

10.1.1.2 静态对象的析构函数

静态对象的析构函数：在程序从Main()中退出来时，或者从标准的C库函数exit()被调用时才被调用；而多数情况下，main函数的结尾也是调用了exit()来结束程序的。这一点也非常重要，这警告了：不要在类的析构函数中调用exit()，有可能会引起无穷的递归调用。

看下面这段代码

#include<iostream>
using namespace std;

class A
{
private:
	int i;
public:
	A(int ii): i(ii) {cout << "This is A() i = " << i << endl;}
	~A() {cout << "This is ~A() i = " << i << endl;}
};

A a(1);

void f()
{
	static A ff;
}

int main()
{
	cout << "Main starts" << endl;
	A aa(2);
	cout << "Main middle" << endl;
	static A aaa(3);
	cout << "Main ends" << endl;
}

编译后程序的输出为:

This is A() i = 1
Main starts
This is A() i = 2
Main middle
This is A() i = 3
Main ends
This is ~A() i = 2
This is ~A() i = 3
This is ~A() i = 1

这说明了以下几点:

1、静态对象的销毁也是按与初始化时相反的顺序进行的。

2、全局静态对象比main函数先初始化，main函数退出后才进行析构。参考全局对象a，其构造函数在main函数开始之前被调用

3、在main函数中，即便局部静态对象aaa比aa晚初始化，但它并没有比aa先调析构函数。并且他也是在main函数退出之后才调用的析构函数。所以有以下结论：
1) 构造函数的调用顺序： 全局静态对象 >  进入main函数  > （局部静态对象  、临时对象）。括号中的对象的调用顺序要看代码中调用的顺序
2) 析构函数的调用顺序：main函数退出 ＞临时对象 > 局部静态对象 > 全局静态对象。同类的对象的析构按与构造函数的调用顺序相反的顺序调用。
这给了我们一种能力：再进入main()之前执行一段代码，并且可以在退出main()之后用析构函数执行代码。

10.1.2 控制连接

这部分主要描述了变量的程序中的可见性问题。先看两个概念：

1、外部链接：一般情况下，在文件作用域内的所有名字在程序中对所有翻译单元都是可见的。因为在连接时这个名字对连接器来说是可见的，对单独的翻译单元来说，它是外部的。全局变量和普通函数都有外部连接。

2、内部连接：在文件作用域内，一个被明确声明为static的对象或函数的名字对翻译单元来说是局部于该单元的，这些名字有内部连接。

10.1.2.1 冲突问题

如果在进入Main()之前定义一个变量 int a = 0; 它等于 extern int a = 0; 说明了两点：1、a是全局可见的，即外部连接的。2、a的值存储在静态区，当main()函数结束后，它才会被释放。

但是如果定义 static int a = 0; 仅改变上述中的第1点，他现在是本文件中可见的，也就是说内部连接的，无论在另一个文件中是否声明extern int a; 都不能引用到该变量。而它依然存储在静态区。

10.1.3

其他存储类型说明符： auto --- 自动变量，可由编译器根据上下文推导出，所以一般用不到。register -- 寄存器类型的变量。即使在程序中声明一个变量为register类，也不能保证它一直存在于寄存器中，这部分工作仍然由编译器完成。

10.2 C++中的静态成员

作用：为某个类的所有对象分配一个单一的存储空间

类的静态成员拥有一块单独的存储区，不管创建了多少个对象。静态数据属于类而不属于某个特定的对象。

10.3.1 定义静态数据成员的存储

方法如下：

在类的定义处，一般是头文件中，在想使之成为静态成员的变量前加上static，如果定义一个静态的全局或局部变量一样。这只是声明

class A{
    static int i;
public:
    //...
};

然后在实现文件中定义，需要使用作用域运算符。

int A::i = 1;

10.3.1.1 静态数组的初始化

1) 内建类型的初始化

//in header
class Values
{
    static const int scInts[];
    static char scChars[];
};
//in cpp
const int Values::scInts[] = "1, 2, 3, 4, 5";
char Values::scChars[] = {'C', 'P', 'L', 'U', 'S'};

可以不在声明时指定数组的大小，而利用自动计数功能确定数组的大小。

2) 类的数组

你可能想既然写好了类的构造函数，利用内联语法在声明时定义另一个类的静态对象或数组，然而这样是不行的，必须像上面一样写在具有静态变量的类的外部。

10.3.2 嵌套类和局部类

可以把一个静态数据成员放在另一个类的嵌套类中，而不能在局部类中定义静态数据成员。比如在一个局部函数内定义一个类的静态成员。理由很简单，局部函数不一定会被调用，其中的数据结构不一定会被初始化。而且静态变量是分配在堆上的，而局部变量时分配在栈上的，这也是矛盾之处。

10.3.3 静态成员函数

其意义与静态数据成员一样，都是为整个类服务的，在整个进程的内存空间只存在一个该函数的存储区。

特点：静态成员函数没有this指针，因此它只能访问这个类之中的其他静态数据成员和调用静态成员函数。见下面的代码段

<span style="font-size:14px;">//c10: StaticMemberFunctions.cpp
#include <iostream>

class X{
	int i;
public:
	static int j;
	X(int ii = 0): i(ii)
	{
		j = i;
		std::cout << "constuctor j = " << j << std::endl; 
	}
	int val() const
	{
		return i;
	}
	static int incr()
	{
		//++i;    //not allowed, static member func can only call static member data
		++j;
		std::cout << "incr j = " << j << std::endl;
		return j;
	}
	static int f()
	{
		//! val(); //error: static member function cannot access non-static member functions
		int tmp = incr();
		std::cout << "f() tmp j = " << tmp << std::endl;
		return tmp;
	}
};

int X::j = 0;

int main()
{
	std::cout << "before constructor X::j = " << X::j << std::endl;
	X x(5);
	std::cout << "after constructor X::j = " << X::j << std::endl;
	X* xp = &x;
	x.f();
	xp->f();
	X::f();
	return 0;
}</span>

注意在原书中，静态变量j是private的，但是我将他改为了public，这样方便打印操作。

打印如下：

before constructor X::j = 0
constuctor j = 5
after constructor X::j = 5
incr j = 6
f() tmp j = 6
incr j = 7
f() tmp j = 7
incr j = 8
f() tmp j = 8

这说明：１、静态数据成员在进入主函数之前就已经被赋值

　　　　２、构造函数是可以修改静态数据成员的值的

　　　　３、静态成员函数可以用对象的方式调用，也可以用类名的方式调用。

由此可以引申出一个常用的设计模式，即单例模式。整个进程的内存空间内只有一份该类的内存映像，保证了数据的唯一性。