静态变量的静态指在整个程序生命周期的地址静止不变。也就是说在整个程序里面只保存有一份拷贝。static关键字允许它在不同的函数调用间保持它的值。如果一个静态变量被访问后值改变，它就会保持新的值。

在C++中，类的静态成员（static member）必须在类内声明，在类外初始化。

要注意的是，静态成员变量在类中仅仅是声明，没有定义，所以要在类的外面定义，实际上是给静态成员变量分配内存。初始化是赋一个初始值，而静态成员变量只需要定义（分配内存）即可，可以不赋初值，类外定义后默认为0。

静态成员函数和静态成员变量的使用都可以通过类名+"::"的方式进行使用，此外，对于类的对象，指针或引用，也可以直接调用。

#include <stdio.h>
class A {
    public:
    static int a; //声明但未定义
};
int A::a ; //定义静态成员变量。不给初值默认为0
int main() {
    printf("%d", A::a);//输出0
    return 0;
}


静态成员属于整个类，而不属于某个对象，如果在类内初始化，会导致每个对象都包含该静态成员。

C++规定，const的静态成员可以直接在类内初始化，而非const的静态成员需要在类外声明以初始化。所以，能在类中初始化的成员只有一种，那就是静态常量成员。

class A
{  // 静态常量成员可以在类内初始化
    private: static const int count = 0;
};

静态成员和常量成员都不能在类内初始化，错误示范：

class A
{   // 静态成员不能在类内初始化
    private: static int count = 0;
};
class A
{   // 常量成员不能在类内初始化
    private: const int count = 0;
};


 

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

作用域: 变量的可见代码域（块作用域，函数作用域，类作用域，程序全局作用域）。

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仍存在于内存之中。

 

一、静态变量：

在了解静态变量之前，读者需要知道什么是全局变量和局部变量。局部变量直至定义在函数内部的变量，在函数调用结束后，局部变量将消失。全局变量是指在函数体外定义的变量，它的生命期随着程序的结束而结束。

对于静态变量读者可以简单粗暴地理解为全局变量，但是二者又有区别。如果定义一个静态的局部变量，它的生命期在函数调用结束后依然存在，在下次调用函数时，会依然保存上一次函数调用结束之后的值。并且，对于静态变量只执行一次初始化（无论函数调用多少次）。在 C++中静态变量是使用 static 关键字来定义的。

void Invoke()
{
    static int s_nNum = 0;  //定义静态局部变量
    cout << s_nNum << endl;
    s_nNum++;
}

int main()
{
    for(int i = 0; i < 10; i++)
        Invoke();
    return 0;
}



注：对于普通的局部变量，在函数调用时每次都会执行初始化操作，并且在函数调用结束后被销毁。对于全局变量来说，不仅能够够在当前文件中使用，而且还可以在其他文件中被使用。但是全局静态变量则不同，它的作用域是当前定义全局静态变量处到当前文件的结束，不能够在其他文件中访问全局静态变量。

二、静态数据成员

在类中使用 static 关键字将数据成员定义为静态成员。静态成员与静态变量是两个完全不同的概念，静态数据成员能够被同一个类的所有对象共享，可以作用于类上，通过类名来访问，简单的说，就是静态数据成员是属于这个类的全局变量。

#include <iostream>
using namespace std;

class CUser
{
private:
    char m_Username[128];
    char m_Password[128];
public:
    static int m_nCount;  //静态数据成员
    CUser()              //默认构造函数
    {
        strcpy(m_Username, "MR");
        strcpy(m_Password, "KJ");
    }
};

int CUser::m_nCount = 10;  //静态成员初始化，不需要在前边加 static

int main()
{
    CUser User;
    cout << "User 静态成员：" << User.m_nCount << endl;
    CUser defUser;
    defUser.m_nCount = 1;
    cout << "defUser 静态成员：" << defUser.m_nCount << endl;
    cout << "User 静态成员：" << User.m_nCount << endl;
    return 0;
}
/*=====output=======
User 静态成员：10
defUser 静态成员：1
User 静态成员：1
==================*/

注：对于 VC++的工程来说，静态数据成员的使用，必须现在 .h 文件中声明 static 变量，然后在对应的 .c 文件头的下方初始化静态数据成员，方可使用，否则会出现编译错误。如果在本类中调用静态数据成员，则只需要object.static；如果想要在其他类中调用另一个类的静态成员，不需要进行额外的任何操作，只需要在调用处成员变量前边加上类名::即可，例如 class::static。

三、外部变量

外部变量用于告诉编译器在其他文件的全局区域存在一个全局变量，目的是在当前文件中能够访问这个全局变量。外部变量的生命需要使用 extern 关键字。例如，在应用程序中，如果在一个文件中定义了一个全局变量，例如 m_nCount，为了在其他文件中能够访问全局变量 m_nCount，那么在其他文件中需要声明一个与 m_nCount 同名的外部变量。

extern int m_nCount;

四、自动变量

（1）C++98 中 auto 特性

自动变量是指变量的生命期在变量的声明时开始，在离开变量的作用域时结束，它仅限于在函数内使用。不可申明为全局的。自动变量用 auto 来声明。

（2）C++11 中 auto 特性

auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型,详见另一位博主的文章

https://www.cnblogs.com/QG-whz/p/4951177.html

 

C++静态变量和静态函数的小结

最近由于工作的关系，要做一个简单的输入法，当然是要移植到arm板上去的。没有想自己做，就到网上找到两个用Qt输入法打代码，自己整合了一下，最后的效果差强人意吧！在这里把整合中遇到的对静态变量的使用的一点小小的总结写在这里，只当自己学习的一个记录，如有错误，还望大家指出，共同提高！
下面通过一个简单的例子来看看：

	class SyszuxIM:public QWSInputMethod
	{
	Q_OBJECT
	public:
	        SyszuxIM();
	        ~SyszuxIM();
	        void updateHandler(int);
	
	        static void installInputMethod();
	        static void releaseInputMethod();
	        static SyszuxIM* instance();
	
	        static SyszuxIM* pInputMethod ;
	public slots:
	        void confirmString(QString gemfield);
	private:
	        SyszuxPinyin* syszuxpinyin;
	        //设置输入法底框的颜色
	        void setInputColor( const QColor &color ) ;
	
	};

这个里面主要是在类中有一个这个类的一个静态的指针变量。以前一直没有这么用过，其实想想在c语言结构体中是经常这么用的。链表中也就是一直这么用的，因为c++的类是结构体的一个扩展。所以在类中这么用也应该是很正常的。
不过在c++中有种新的用法：
	struct SyszuxIMPrivate
	{
	        static SyszuxIM* pInputMethod;
	};

因为毕竟不是要做链表用，所以单独用一个结构体来定义一个数据类型。这样看着舒服些。在这里记录一笔只是给自己留个记号，以后自己程序中可以这么用。
下面是对静态变量与静态函数的一个总结，作为自己的个备忘录,

在C语言中有静态数据类型，声明一个静态数据类型意味着：该变量的生存周期是

静态的，即在程序的开始即分配到程序，终止时才释放。在C++中，声明一个类的静态数据成员意味着所有的实例只有该数据成员的一个拷贝。

  《深入浅出MFC》这样解释：

   Static 成员不属于对象的一部分，而是类的一部分。所以程序可以在没有诞生分和

　 对象的时候就处理此种成员变量.但必须首先初始化它。

　 不要把static成员变量的初始化操作安排在类的构造函数中，因为构造函数可能一　　

再被调用，而变量的初值只应该设定一次。也不要把初始化操作安排在头文件中，

因为它可能被载入到许多地方，因此就可能执行许多次。你应该在应用程序文件中，

类以外的任何地方设定其初始值。例如在main之中，或者全局函数中，或任何函数

之外：
double SavingAccount :: m_rate = 0.0075;//设定atatic成员变量初值
void main() {… …}


这么做可曾考虑到m_rate是个private数据？没关系，设定static成员变量初值

时，不受任何存取权限的束缚。请注意，static成员变量的类型也出现在初值设定

中，因为这是一个初值设定操作，不是一个赋值（assignment）操作。事实上，staic

变量在这个时候（而不在类声明中）才定义出来。如果你没有做这个初始化操作，

会产生连接错误。

下面是存取static成员变量的一种方式，注意，此刻还没有任何对象实例：

／／第一种存取方式：
void main()
{
  SavingAccount::m_rate = 0.0075; //欲此成立，须把m_rate改为public
}


下面是这种情况则是产生一个对象后，通过对象来处理static成员变量：

／／第二种存取方式：
void main()
{
   SavingAccount myAccount;
   myAccount.m_rate = 0.0075;  //欲此成立，须把m_rate改为public
}


Static成员变量并不是因为对象的实现才得以存在的，它本来就存在，你可以想象

它是一个全局变量。只要access level允许，任何函数都可以存取static成员变

量。但是如果你希望在产生任何对象之前就存取其class的private　static成员

变量，则必须设计一个static成员函数：

由于static成员函数不需要借助于任何对象，就可以被调用，所以编译器不会为它

暗加一个this指针。因此static成员函数无法处理类之中的non-static成员变量。