本篇主要讲述类中静态变量相关基础：

1. 静态变量的特点
   局域作用域中静态变量并不会随着函数的每一次调用而产生一个副本，也不会随着函数的返回而导致变量的失效。
2. 静态变量的意义
   在一个class类中，private修饰的成员属性可以看为是没一个实例对象的属性,但是有的时候，有些属性是属于整个类所共有的，比如Family类下有一个属性“家庭成员数量”，事实上如果将它定义为每个对象的属性，那么会造成空间的很大浪费，而如果将“家庭成员数量”定义为静态变量，那么则可以所有成员都共享一个内存空间，并且做到整体一致性的修改。
3. 静态变量的定义
   定义：不在public、private、protected里，而是单独定义，
   但并不表示说不能用三者修饰，例如定义一个静态整型变量a是可以的：
   private:
   static int a;
   格式为：static <数据类型> <变量名>
   （必须在类的声明中声明，但是初始化必须在类的外部）
4. 静态变量的初始化
   <数据类型> <类名>::<静态变量名> <=初始值>
5. 实例
   UML图如下：
   相关代码

#include<iostream>
using namespace std;

class Point
{
	static int count;	//类的定义中仅仅对静态数据成员进行引用性声明
public:
	Point(int xx = 0, int yy = 0);
	Point(Point& p);
	~Point() { count--; }
	int getX(){return x;}
	int getY(){return y;}
	void showCount()
	{
		cout << "count : " << count << endl;
	}
private:
	int x;
	int y;
};
int Point::count = 0;	//使用类名限定定义性声明，并初始化
Point::Point(int xx, int yy) : x(xx), y(yy)
{
	Point::count++;
};
Point::Point(Point& p)
{
	x = p.x;
	y = p.y;
}

int main()
{
	Point a(4, 5);
	cout << "Point A:" << a.getX() << " , " << a.getY() << endl;
	a.showCount();
	Point b(a); 
	cout << "Point B:" << b.getX() << " , " << b.getY() << endl;
	b.showCount();
	return 0;
}

c语言中

c语言中需要内存来存放数据。而内存主要分为两类：静态存储区和动态存储区;

1. 静态存储区分为：只读数据（READONLY DATA）区、以读写数据（RW DATA）区、未初始化区（BSS）。它们都是在程序编译连接阶段确定的，在程序执行的阶段不会改变。

2. 动态存储区分为堆和栈。都是程序执行的过程中动态分配的，大小也随之动态变化。从内存管理的实现的角度看来，堆使用的链表实现的，而栈使用的是线性存储的方法。

栈：栈是先进后出，实际的操作中，栈内存可以有满栈和空栈的情况，满栈的情况下，栈指针当前的位子是已经使用的的栈区域；空栈的情况是，栈指针当前的位子是没有使用的栈区域，所以两种情况的出入栈，指针和数据的操作先后顺序是不同的。

• 满栈时：入栈，是先移动指针，在放入数据；出栈则是先出数据，在移动指针；
• 空栈时：入栈，是先放入数据，在移动指针。出栈则是先移动指针，在出数据；

C语言必须注意的几个问题:

1. 内存泄露：申请一块内存，但没有释放，程序结束也没回收，导致其他程序不能使用
2. 野指针：指一个内存指针已经被释放free或者realloc，但指针依然在使用。避免野指针的情况，将内存的指针置为NULL，并在程序使用的时候判断该内存是否为NULL，如为空，则认为该内存已经释放，不对内存进行访问。
3. 非法释放内存：原则上讲只有被malloc(),calloc()或realloc()分配并通过返回值返回返回的内存才能被释放，否则释放除此以外的内存都是非法的。即使有一个指针是*p是malloc，那么对p1=p++，这个时候free(p1)也是不合法的，但free( p) 确实可以的。同样释放函数中的局部变量也是非法的.还有一种情况是，对一个堆内存释放两次也是错误的用法。因为free()函数是不能释放未分配的堆内存。在程序使用free释放内存之后，应该将指针置为NULL，free一个NULL地址是没有问题的。

c中：

• 在介绍之前，先讨论一下 堆，栈，自由存储区，全局/静态存储区和常量存储区

1. 堆：用new分配，free释放
   自由存储区：malloc分配，delete释放
2. 栈：编译器管理的局部变量和函数参数等。
   全局/静态存储区：存储静态变量和全局变量
3. 字符常量区：常量存储的内存

也就是说static修饰函数的仅有一个意思：就是告诉编译器，我是一个内部函数，不要随便的用我。

5. static 变量
   静态变量的类型 说明符是static。 静态变量当然是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量。 例如外部变量虽属于静态 存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。

6. 静态局部变量
   静态局部变量属于静态存储方式，它具有以下特点：

   • 静态局部变量在函数内定义 它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后， 尽管该变量还继续存在，但不能使用它。

   • 允许对构造类静态局部量赋初值 例如数组，若未赋以初值，则由系统自动赋以0值。

   • 对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。 根据静态局部变量的特点， 可以 看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用， 而且保存了前次被调用后留下的 值。 因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成 意外的副作用，因此仍以采用局部静态变量为宜。

7. 静态全局变量
   全局变量(外部变量)的说明之前再冠以static 就构 成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局 变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在 定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此 可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量 后是改变了它的作用域， 限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。

8. static 函数……
   内部函数和外部函数:当一个源程序由多个源文件组成时，Ｃ语言根据函数能否被其它源文件中的函数调用，将函数分为内部函数和外部函数。

   • 内部函数（又称静态函数）
     如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数称为内部函数。定义一个内部函数，只需在函数类型前再加一个“static”关键字即可，如下所示：

    static  函数类型  函数名(函数参数表)
    　　　　　　{……}

关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。

2. 外部函数
   　　外部函数的定义：在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数：
   　　　　[extern] 函数类型 函数名(函数参数表)
   　　　　　　{……}
   调用外部函数时，需要对其进行说明：
   [extern] 函数类型 函数名(参数类型表)[，函数名2(参数类型表2)……]；

[案例]外部函数应用。
（1）文件main.c

　main()
　　　{  extern void input(…),process(…),output(…);

　　　　input(…);  process(…);  output(…);

　　  }

（2）文件subf1.c

　extern  void input(……)                           /*定义外部函数*/
　　{……}

（3）文件subf2.c

　　……
　　extern  void process(……)                     /*定义外部 函数*/
　　{……}

（4）文件subf3.c

　　……
　　extern void output(……)                        /*定义外部函数*/
　　{……}

C++中的静态成员变量和静态成员函数

1. 类静态数据成员在编译时创建并初始化：在该类的任何对象建立之前就存在，不属于任何对象，而非静态类成员变量则是属于对象所有的。类静态数据成员只有一个拷贝，为所有此类的对象所共享。特别需要注意的一点是：静态数据成员不能在类中初始化(对于常量静态类变量有待考证，好像可以在类外或main()函数之前定义，初始化可以放在类中)，一般在类外和main()函数之前初始化，缺省时初始化为0。静态数据成员用来定义类的各个对象所公有的数据，比全局变量更安全。

2. 类静态成员函数属于整个类，不属于某个对象，由该类所有对象共享。静态成员可定义为inline函数。一般情况下静态成员函数用于访问同一类中的静态数据成员或全局变量，而不访问非静态成员，如需访问非静态成员，需要将对象作为参数，通过对象名访问该对象的非静态成员。静态成员函数也可以在类外定义，此时不可以用static修饰。静态成员函数存在的原因是什么呢？主要是在建立任何对象之前可用它来访问静态数据成员，普通函数不能实现此功能。

C++静态成员和静态成员函数的使用：静态成员的调用格式：类名：：静态数据成员名、对象名.静态数据成员名、对象指针->静态数据成员、对象引用.静态数据成员(但类中很少会出现公有数据成员，这段仅仅讨论语法，未考虑实际运用中的数据封装问题)。静态成员函数的调用格式：类名：：静态成员函数名、对象名.静态成员函数名、对象指针->静态成员函数名、对象引用.静态数据成员。静态成员函数没有this指针，因它不与特定对象相联系，调用时推荐使用“类名：：静态成员函数名”格式。总结来说，在有对象的情况下，可以用调用普通类成员函数、普通成员变量的方式调用静态成员函数和静态成员变量。从这里可以看出静态成员变量和静态成员函数的使用应该是在不建立任何对象的情况下调用它们。其应用可以参见设计模式中Singleton pattern。

首先要理解生存周期与作用域的区别： 
生存周期: 变量从定义到销毁的时间范围。存放在全局数据区的变量的生存周期存在于整个程序运行期间，而存放在栈中的数据则随着函数等的作用域结束导致出栈而销毁，除了静态变量之外的局部变量都存放于栈中。 
作用域: 变量的可见代码域（块作用域，函数作用域，类作用域，程序全局作用域）。

static变量是指静态的变量，不管是在全局还是局部声明的static变量都存放于程序的全局变量区域，所以它的生命周期是从程序开始到程序结束。但是static变量的作用域并不等同于它的生存周期，它的作用域决定于它被定义的位置。可以认为static变量的作用域<=生存周期。

举一个局部声明的例子。在函数test中声明静态变量i： 

#include<iostream>
using namespace std;
void test();//函数原型

void test()
{
	static int m=5;
	m+=1;
	cout<<m<<endl;	//m作为静态变量，存在于整个程序运行周期中， 
}
int main()
{

	//int m=3; 
	 static int i=5;
	i=5;
	test();
	test();
	test();
	test();
	test();
	return 0;
}

运行结果

局部变量m存放在栈中，当test函数结束，m将被销毁；静态变量i不存放在栈中，而是存放于程序的全局变量区域，因此随着函数test的结束，它并不随着出栈操作而被销毁，它的生存周期存在于程序的整个运行期；然而m和i的作用域都仅存在于test函数中它们的定义之后，即test调用结束之后，m和i就不再可用，m消失，但是i仍存在于内存之中。