静态成员变量初始化

       静态成员变量可以初始化，但只能在类体外进行初始化。如：

long long student::number = 13926572996;    //在类体外对静态成员变量赋值

其一般形式为：

数据类型 类名：：静态成员变量名 = 初值；

不必在初始化赋值语句中加 static。

       注意：不可以在构造函数的参数初始化表中对静态成员变量初始化，例如：

    student(char* pn, char* pa, int n):number(n)

    {

        strcpy(name, pn);

        strcpy(addr, pa);

    }

       在构造函数中，对static类型的number成员进行初始化，是错误的操作。

如果未对静态成员变量赋值，则编译系统会自动赋初值为0。

如果一个成员变量定义为const类型，同时，也是static类型，那么，应该怎么样初始化？有如下的分析：

(1) static类型的成员变量，需要在类外进行初始化；

(2) const类型的成员变量，需要在构造函数的初始化列表进行初始化；

       那么，const类型的static成员变量，不可以在构造函数的初始化列表中进行初始化，例如：

       程序编译错误，如下：

       提示 student::number成员变量是static类型，仅仅在定义的时候可以初始化。所以，不可以在构造函数列表中初始化。所以，在类外对static类型的成员变量进行初始化，程序测试代码如下：

       程序运行结果如下：

       所以，可以在类外对const类型的静态成员变量进行初始化。

       注意：对于const 类型的static成员变量，可以在定义它的时候进行初始化，如下：

       在student类内对number成员进行初始化。这是合法的语句。

韦凯峰 Linux C/C++ 程序设计教程，Linux 系统编程，Openwrt 系统开发，微信:13926572996,QQ:1523520001,博客:www.mylinux.vip

注意：本文所说的全局变量指的是 variables with static storage，措词来自 c++ 的语言标准文档。

什么时候初始化

根据 C++ 标准，全局变量的初始化要在 main 函数执行前完成，常识无疑，但是这个说法有点含糊，main 函数执行前到底具体是什么时候呢？是编译时还是运行时？答案是既有编译时，也可能会有运行时(seriously), 从语言的层面来说，全局变量的初始化可以划分为以下两个阶段（c++11 N3690 3.6.2)：

static initialization: 静态初始化指的是用常量来对变量进行初始化,主要包括 zero initialization 和 const initialization，静态初始化在程序加载的过程中完成，对简单类型(内建类型，POD等)来说，从具体实现上看，zero initialization 的变量会被保存在 bss 段，const initialization 的变量则放在 data 段内，程序加载即可完成初始化，这和 c 语言里的全局变量初始化基本是一致的。

dynamic initialization：动态初始化主要是指需要经过函数调用才能完成的初始化，比如说：int a = foo()，或者是复杂类型（类）的初始化（需要调用构造函数）等。这些变量的初始化会在 main 函数执行前由运行时调用相应的代码从而得以进行(函数内的 static 变量除外)。

需要明确的是：静态初始化执行先于动态初始化！ 只有当所有静态初始化执行完毕，动态初始化才会执行。显然，这样的设计是很直观的，能静态初始化的变量，它的初始值都是在编译时就能确定，因此可以直接 hard code 到生成的代码里，而动态初始化需要在运行时执行相应的动作才能进行，因此，静态初始化先于动态初始化是必然的。

初始化的顺序

对于出现在同一个编译单元内的全局变量来说，它们初始化的顺序与他们声明的顺序是一致的（销毁的顺序则反过来），而对于不同编译单元间的全局变量，c++ 标准并没有明确规定它们之间的初始化（销毁）顺序应该怎样，因此实现上完全由编译器自己决定，一个比较普遍的认识是：不同编译单元间的全局变量的初始化顺序是不固定的，哪怕对同一个编译器，同一份代码来说，任意两次编译的结果都有可能不一样[1]。

因此，一个很自然的问题就是，如果不同编译单元间的全局变量相互引用了怎么办？

当然，最好的解决方法是尽可能的避免这种情况(防治胜于治疗嘛)，因为一般来说，如果出现了全局变量引用全局变量的窘况，那多半是程序本身的设计出了问题，此时最应该做的是回头重新思考和修改程序的结构与实现，而不是急着穷尽技巧来给错误的设计打补丁。

—- 说得轻松。

几个技巧

好吧，我承认总有那么一些特殊的情况，是需要我们来处理这种在全局变量的初始化函数里竟然引用了别的地方的全局变量的情况，比如说在全局变量的初始化函数里调用了 cout, cerr 等(假设是用来打 log, 注意 cout 是标准库里定义的一个全局变量)[2]，那么标准库是怎样保证 cout 在被使用前就被初始化了呢？ 有如下几个技巧可以介绍一下。

(1)Construct On First Use

该做法是把对全局变量的引用改为函数调用，然后把全局变量改为函数内的静态变量：

int get_global_x()
{
   static X x;
   return x.Value();
}
 
1
2
3
4
5

这个方法可以解决全局变量未初始化就被引用的问题，但还有另一个对称的问题它却没法解决，函数内的静态变量也属于 variables with static storage, 它们析构的顺序在不同的编译单元间也是不确定的，因此上面的方法虽然必然能保证 x 的初始化先于其被使用，但却没法妥善处理，如果 x 析构了 get_global_x() 还被调用这种可能发生的情况。

(2)一个改进的做法是把静态变量改为如下的静态指针：

int get_global_x()
{
   static X* x = new X;
   return x->Value();
}
 
1
2
3
4
5

这个改进可以解决前面提到的 x 析构后被调用的问题，但同时却也引入了另一个问题: x 永远都不会析构了，内存泄漏还算小问题或者说不算问题，但如果 x 的析构函数还有事情要做，如写文件清理垃圾什么的，此时如果对象不析构，显然程序的正确性都无法保证。

(3)Nifty counter.

完美一点的解决方案是 Nifty counter, 现在 GCC 采用的就是这个做法[3][7]。假设现在需要被别处引用的全局变量为 x, Nifty counter 的原理是通过头文件引用，在所有需要引用 x 的地方都增加一个 static 全局变量，然后在该 static 变量的构造函数里初始化我们所需要引用的全局变量 x，在其析构函数里再清理 x，示例如下：

// global.h

#ifndef _global_h_
#define _global_h_


extern X x;

class initializer
{
   public:
     initializer()
     {
        if (s_counter_++ == 0) init();
     }

     ~initializer()
      {
        if (--s_counter_ == 0) clean();
       }

   private:
      void init();
      void clean();

      static int s_counter_;
};

static initializer s_init_val;

#endif
相应的 cpp 文件：

// global.cpp

#include "global.h"

static X x;

int initializer::s_counter_ = 0;

void initializer::init()
{
    new(&x) X;
}

void initializer::clean()
{
   (&x)->~X();
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

代码比较直白，所有需要引用 x 的地方都需要引用 global.h 这个头文件，而一旦引入了该头文件，就一定会引入 initializer 类型的一个静态变量 s_init_val, 因此虽然不同编译单元间的初始化顺序不确定，但他们都肯定包含有 s_init_val，因此我们可以在 s_init_val 的构造函数里加入对 x 的初始化操作，只有在第一个 s_init_val 被构造时才初始化 x 变量，这可以通过 initializer 的静态成员变量来实现，因为 s_counter_ 的初始化是静态初始化，能保证在程序加载后就完成了。

初始化 x 用到了 placement new 的技巧，至于析构，那就是简单粗暴地直接调用析构函数了，这一段代码里的技巧也许有些难看，但都是合法的，当然，同时还有些问题待解决：

首先，因为 x 是复杂类型的变量，它有自己的构造函数，init() 函数初始化 x 之后，程序初始化 x 所在的编译单元时，x 的构造函数还会被再调用一次，同理 x 析构函数也会被调用两次，这显然很容易引起问题，解决的方法是把 x 改为引用：

// global.cpp

#include "global.h"

// need to ensure memory alignment??
static char g_dummy[sizeof(X)];

static X& x = reinterpret_cast<X&>(g_dummy);

int initializer::s_counter_ = 0;

void initializer::init()
{
    new(&x) X;
}

void initializer::clean()
{
   (&x)->~X();
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

其中 static X& x = reinterpret_cast

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

转载自：http://blog.csdn.net/zhufenglonglove/article/details/52401939

（1）C语言从语法上规定全局变量只能用常量表达式来初始化，因此下面这种全局变量初始化是不合法的：

int minute = 360;
int hour = minute / 60; 

虽然在编译时计算出 hour 的初始值是可能的，但是 minute / 60 不是常量表达式，不符合语法规定，所以编译器不必想办法去算这个初始值。

（2）全局变量在定义时不初始化则初始值是0，局部变量在定义时不初始化则初始值是不确定的。
所以，局部变量在使用之前一定要先赋值，如果基于一个不确定的值做后续计算肯定会引入Bug。

（3）关于形参和实参
记住这条基本原理：形参相当于函数中定义的变量，调用函数传递参数的过程相当于定义形参变量并且用实参的值来初始化

（4）关于局部变量和临时变量
假设写了一个如下的返回布尔值的函数

int is _even(int x)
{
	if(x%2==0)
		return 1;
	else
		return 0;
}
与之等价的，可以直接写成：
int is even(int x)
{
	return !(x%2);
}

例如上面的函数调用相当于这样的过程：

参考：<Linux C 一站式编程>