**************************C++中的static的用法********************************

*******************************************************************************
C++primer里面讲过：static成员它不像普通的数据成员，static数据成员独立于该类的任意对象而存在，每个static数据成员是与类关联的对象，并不与该类的对象相关联！这句话可能比较拗口，其实可以这么理解：每个static数据成员可以看成是类的一个对象，而不与该类定义的对象有任何关系！下面我们就来具体看看类中的static数据成员！

一、static变量 修饰数据成员

1、static变量 （ 修饰数据成员） 的例子： 

#include<iostream>
#include<string>
using namespace std;

class Person
{
private:
        string name;
        static int age;  //static数据成员age
public:
        Person(const string &nm):name(nm){};
        void Print();
};
int Person::age = 20; //对static数据成员进行初始化

void Person::Print(){
        cout<<name<<" is "<<age<<endl;
}

int main(int argc,char **argv)
{
        Person person("tom");
        person.Print();
        Person person2("nike");
        person2.Print();
        person.Print();
        return 0;
}

解释一哈：
     对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论是这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由改类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，他的值可以更新。

    静态数据成员初始化格式：＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞

   存储：static数据成员是存储在程序的静态存储区，并不是在栈空间上的。（一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。）

    初始化：在类中不能对static数据成员进行初始化，要初始化的话必须在类外进行定义！ static数据成员不是通过类构造函数进行初始化的！如上面的代码所示：在类外定义int Persion::age = 20;这里前面就不加static 了。

    如何访问static数据成员：我们可以通过作用域操作符从类直接调用static数据成员；或者通过对象；或者通过引用；或者指向改类类型对象的指针间接调用（这种情况下static数据成员是public的访问权限，如果定义在private访问权限下是不行的）。

    注意：如果类中有多个static数据成员，static数据成员初始化的次序是按照static数据成员在类中的声明次序进行初始化的，初始化后，就可以使用static数据成员了。

    总结：在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝。

2、const static数据成员 的例子： 

像上面说的，类的static成员，智能在类的定义体外进行初始化。const int 类型的static成员便可以在类定义体内部进行初始化。记住，一定只能是const int型的，换成const string ,double都不行的。

#include<iostream>
#include<string>
using namespace std;
class Person
{
private:
        string name;
        static const int age = 20;//在类的定义体内进行初始化
        static string address;
public:
        Person(const string&nm):name(nm){}
        static string Address()
        {
                return address;
        }
        void Print()
        {
                cout<<name<<" is "<<age;
        }
};
string Person::address = "XiangGang"; //在类的定义体外进行初始化

int main()
{
        Person person("tom");
        person.Print();
        cout<<" and live in "<<person.Address();
        cout<<endl;
        return 0;
}

解释一哈：

    只有age才能在类定义体内进行初始化，address是不行的。

3、****** 的例子： 

    static数据成员的类型可以是该成员所属的类的类型，非static数据成员被限定为其自生类的指针或引用。

class Person
{
private:
        string name;
        static const int age = 20;//在类的定义体内进行初始化
        static string address;
        static Person person1;
        Person *person2;
        Person person3;
public:
        Person(const string&nm):name(nm){}
        static string Address()
        {
                return address;
        }
        void Print()
        {
                cout<<name<<" is "<<age;
        }
};

解释一哈：

    如果没有定义person3,则能顺利通过编译，但是加上person3就不能通过编译了。

二、static变量 修饰成员函数： 

#include<iostream>
using namespace std;
class Myclass
{
public:
        Myclass(int a,int b,int c);
        static void GetSum();//声明静态成员函数
private:
        int a,b,c;
        static int Sum;//声明静态数据成员
};
int Myclass::Sum = 0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
        this->a = a;
        this->b = b;
        this->c = c;
        Sum += a+b+c;//非静态成员函数可以访问静态数据成员
}

void Myclass::GetSum() //静态成员函数的实现
{
//      cout<<a<<endl; //error a是非静态数据成员        
        cout<<"Sum = "<<Sum<<endl;
}

int main()
{
        Myclass M(1,2,3);
        M.GetSum();
        Myclass N(4,5,6);
        N.GetSum();
        Myclass::GetSum();
}

解释一哈：

    非静态成员函数可以访问，静态数据成员与普通数据成员；静态成员函数只能访问，静态数据成员，不能访问非静态数据成员。

      说完了static成员后，我们再来看看static成员函数，static成员是类的组成部分并不是任何对象的组成部分，因此,static成员函数没有this指针。我们知道,一般而言，类中的成员函数具有一个附加的隐含实参，即指向该类对象的一个指针。这个隐含实参命名为this。因为static成员函数不是任何对象的组成部分，所以static成员函数就没有this形参了。由于成员函数声明为const说明该成员函数不会修改该成员函数所属的对象，所以static成员函数不能声明为const。为什么呢？因为static成员函数不是任何对象的组成部分。static成员函数可以直接访问所属类的static成员，但是不能直接使用非static成员函数！也不能访问static const 类型的成员！在上面的代码中static  string Address（）函数中如果是return name或者是return age都不行！ 

 注意：

     *出现在类体外的函数是不能指定关键字static的；

     *静态成员之间可以相互访问，  包括静态成员函数访问静态数据成员和访问静态成员函数；

      *非静态成员函数可以任意访问静态成员函数和静态数据成员；

      *静态成员函数不能访问非静态成员函数和非经验数据成员；

      *因为没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度会有少许的增长；

      *调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：
＜类名＞::＜静态成员函数名＞（＜参数表＞）调用类的静态成员函数。

    总结：在类中的static成员函数属于整个类所拥有，这个函数不接受this指针，因而只能访问类的static成员变量。

参考的网址：

   1》C++类中的static数据成员、static成员函数：https://www.cnblogs.com/yyxt/p/4802688.html

   2》C++中static的完全解析：https://blog.csdn.net/jsjwql/article/details/1788286

转载自：https://blog.csdn.net/computer_liuyun/article/details/29235111

c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西，好像也是找工作公司面试中常常问到的东西。我自己也深有体会，在学习c++的过程中，总感觉static很烦人，但是又是一个必须懂的东西，所以今天就对静态数据成员和静态成员函数坐下小结哈！

一、静态数据成员

1.静态数据成员怎么去定义？

在类中声明静态数据成员很简单，是以static关键字表明即可，如下所示

class Test{
private:
	//静态数据成员
	static int a;
};

a就是静态数据成员了，在类中只能声明可是不能定义哈！

要对静态数据成员定义和初始化必须在类的外面也就是在全局作用域中定义，如果定义不给出初值，则默认初值为0

class Test{
public:
	int GetA() const{return a;}
private:
	//静态数据成员
	static int a;
};
//int Test::a;如果这样定义不赋予初值则初值为零
int Test::a = 1;
#include <iostream>
int main()
{
	Test T;
	std::cout << T.GetA() << std::endl;
}

定义时一定要在全局作用域中定义，一定不要在类中定义！

静态数据成员甚至在类没有任何对象的时候都可以访问，静态成员可以独立访问，无需依赖任何对象的建立

另外，不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。即使加上#ifndef #define #endif或者#pragma once也不行。

2.静态数据成员被类的所有对象共享，包括该类的派生类对象，基类对象和派生类对象共享基类的静态数据成员

答：静态数据成员不属于任何对象，类的静态数据成员的存在不依赖于任何类对象的存在，静态数据成员是由类的所有对象共享的。例子如下：

class Base{
public:
	//静态数据成员
	static int a;
};
class Derived : public Base{
 
};
//int Test::a;如果这样定义不赋予初值则初值为零
int Base::a;
#include <iostream>
int main()
{
	Base B;
	Derived D;
	B.a++;
	std::cout << B.a << std::endl;
	D.a++;
	std::cout << D.a << std::endl;
	
}

打印结果如下：

由打印结果看出来，派生类对象和基类对象都是共享基类的静态数据成员，而基类的所有对象也是共享该静态数据成员，且该静态数据成员应该在全局作用域中定义，可以赋予初值也可以不赋予初值，如果不赋予初值，静态数据成员有其默认值。

3.静态数据成员可以作为成员函数的默认形参，而普通数据成员则不可以

答：不多说，直接看例子马上就明白了哈！

class Test{
public:
	//静态数据成员
	static int a;
	int b;
	void fun_1(int i = a);//正确
	void fun_2(int i = b);//报错
};

4.静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的 指针或引用

答:这个也不多说，直接看例子就可以懂什么意思哈！

class Test{
public:
	//静态数据成员
	static Test a;//正确
	Test b;//报错
	Test *pTest;//正确
	Test &m_Test;//正确
	static Test *pStaticObject;//正确
};

5.静态数据成员在const函数中可以修改，而普通的数据成员是万万不能修改的哈！

答：看个例子

class Test{
public:
	Test():b(0){}
	//静态数据成员
	static int a;//正确
	int b;
	void test() const
	{
		a++;
		b++;//const指的不能修改当前调用该函数对象的数据成员
	}
};
int Test::a;

const修饰的时当前this指针所指向的对象是const，但是静态数据成员不属于任何类的对象，它被类的所有对象修改，所以this指针不修饰静态的数据成员，所以可以更改。

二、静态成员函数

静态成员函数的声明也很简单，就是在类的成员函数前加上static关键字即可，和静态成员一样，静态成员函数也是属于类的，它并不属于任何对象，当调用静态成员函数时应该使用类名和域运算符“∷”，当然也可以使用对象调用操作，但是这样的操作并不意味着静态成员函数属于这个对象，它只是被这个对象共享而已，这样也就决定了静态成员函数中是不能访问本类中的非静态数据成员的，它是不能访问非静态数据成员的，在c++中静态成员函数主要用来访问静态数据成员而不访问非静态数据成员

1.静态成员函数不能调用非静态成员函数，但是反过来是可以的

2.静态成员函数没有this指针，也就是说静态成员函数不能使用修饰符(也就是函数后面的const关键字)

3.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用 类成员函数指针来储存。

总结：其实声明为静态，不论是静态数据成员还是静态成员函数，它们都是不依赖于对象而存在的，类在定义后并不分配存储空间，而是在定义类的对象的时候才分配存储空间，相反静态的数据成员和静态的成员函数是已经在内存中开辟了内存空间了，所以静态数据成员可以独立的访问在任何类对象没有建立起来都可以访问，并且静态成员函数不可以调用非静态成员函数，因为非静态成员函数只有在类对象建立以后才可以调用，相反则是可以的。我觉得当对某个判断产生怀疑的时候应该去测试，只有验证了才知道是不是对的哈！

为了能更好阐释静态数据成员和静态成员函数，然后在网上搜了博客，感觉有些例子不错(因找不到最初的出处，所以无法注明请原作者谅解)，所以就拿来给大家参考一下哈！

关于玩篮球的例子很能明显解释静态数据成员和静态成员函数到底是怎么回事

你们班里面有10个人（10个比如高一一班的对象），体育老师分给你们一个篮球（静态成员函数），你们每个人都带了一个篮球（非静态成员数），你们都很小气，自己的球只能自己拍，要是5对5打比赛，那就只能用那个静态的篮球了（每个人都可以拿来用，但是带来的影响是对全体的）。因此，我可以说那个篮球是高一一班的成员。所以也就是说：静态成员函数是类的成员函数（因为高一二班就不能拿来玩），但是这个篮球最后还是要还给老师的，任何私人不得占有。希望这样你能明白，其实在内存空间里面说白了静态的成员的内存是唯一的一份，就是当你在类外声明他时开辟的，但是非静态函数的空间分配是在你实例化对象时创建的。

为了使大家更好的理解这两个概念，还是老样子用代码来说明上面文字说明的这一切哈！

关于学生类的例子

//定义Student类
#include <iostream>
class Student                  
{
public:
//定义构造函数
Student(int n,int a,float s):num(n),age(a),score(s){ }      
void total();
//声明静态成员函数
static float average();      
private:
	int num;
	int age;
	float score;
	//静态数据成员，累计学生的总分
	static float sum; 
	//静态数据成员，累计学生的人数
	static int count;           
};
//在全局作用域对静态数据成员初始化，如果不赋予初值，则使用其默认值零
float Student::sum;                     
int Student::count;
//定义非静态成员函数
void Student::total()                    
{
	//累加总分
	sum+=score;
	//累计已统计的人数
	count++;                               
}
//定义静态成员函数
float  Student::average()                  
{
	return(sum/count);
}
int main()
{
	Student stud[3]={    
	//定义对象数组并初始化
	Student(1001,18,70),
	Student(1002,19,78),
	Student(1005,20,98)
};
int n;
std::cout<<"please input the number of students: ";
 //输入需要求前面多少名学生的平均成绩
std::cin>>n;                              
//调用3次total函数
for(int i=0;i<n;i++)
{
	stud[i].total();
}
//调用静态成员函数
std::cout<<"the average score of "<<n<<" students is "<<Student::average( )<<std::endl;
return 0;
}

打印输出如下：

对上面的代码做以下说明：

首先，在主函数中定义了对象数组，存放每个学生的编号、年龄和成绩，其中sum和count是要累计所有学生的总成绩和总的学生人数，我们定义成了静态数据成员，在学生类的成员函数中，我们定义了普通的total成员函数，用来计算所有学生的总成绩和总的学生人数，另外，定义了静态成员函数average，学生类的设计大概如此

在全局作用域对类中静态数据成员进行了定义，但未赋予初值，这意味着我们采用其默认值。

在类的普通成员函数toal中可以引用静态数据成员sum和count，可见类的所有成员函数都可以引用类的静态数据成员。

在类的静态成员函数average中，只能引用类的静态数据成员，不能引用非静态数据成员。

在主函数中我们调用类的非静态成员函数时只能通过类对象来调用，如stu[i].total，但是对于静态成员函数可以直接通过类名+作用域符号来调用，如

Student::average。

有关const成员、static成员、const static成员的初始化：

1、const成员：只能在构造函数后的初始化列表中初始化（C++98）；

   (C++11提供了类内初始化，因此内类常量可在声明类时进行类内初始化，因此该类内常量的作用域属于类级，即该类的所有对象均具有同一个值。)

#include <iostream>
using namespace std;
class A {
public:
	A(int j) :m_j(j) {}
private:
	const int m_i = 6;
	const int m_j;
};
int main()
{
	system("pause");
	return 0;
}

const作为类成员为什么只能在初始化列表中被初始化呢？

构造函数创建对象时，对象在执行构造函数函数体前（即大括号之前）被创建（即分配存储空间）。因此，调用构造函数将为对象的成员变量分配内存。然后程序流程进入到构造函数函数体（大括号中的代码），使用常规的赋值方式对成员变量进行赋值。因此，对于const数据成员，必须在执行到构造函数体之前，即创建对象（即为const变量分配内存时），进行初始化。因此，const成员不能通过普通的构造函数来初始化。

2、static成员：初始化在类外，且不能加static修饰

#include <iostream>
using namespace std;
class A {
private:
	//static int m_i = 5;错误
	static int m_i;
};
int A::m_i = 5;
int main()
{
	system("pause");
	return 0;
}

3、const static成员：类只有唯一一份拷贝，且数值不能改变。因此，可以在类中声明处初始化，也可以像static在类外初始化

#include <iostream>
using namespace std;
class A {
private:
	static const int m_i;
	int k[m_i];//错误，编译期间无法获得m_i的值
};
const int A::m_i =6 ;
int main()
{
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
class A {
private:
	static const int m_i = 5;
	int k[m_i];
};
const int A::m_i;
int main()
{
	system("pause");
	return 0;
}

如果要取static const 成员变量地址，则必须对其变量进”类外定义“（该定义不指定值，容易误解为声明），因为编译器要求，如果要对内类const进行取地址，必须提供定义式。而且注意：VS2015等编译期对此做了优化，可以不按上述说法，但是在g++中，需按上述说法严格执行

#include <iostream>
class A {
        public:
                static const int m_i=5;
};
//const int A::m_i;

int main()
{
        A a;
        std::cout << &(a.m_i) << std::endl;
        return 0;
}

#include <iostream>
class A {
        public:
                static const int m_i=5;
};
const int A::m_i;

int main()
{
        A a;
        std::cout << &(a.m_i) << std::endl;
        return 0;
}

4.C++中普通成员变量可以在类内初始化吗？

#include <iostream>
class A {
        public:
                int i=6;
};
int main()
{
        return 0;
}

但是在C++11标准允许在类定义时初始化数据成员，所以VS2015不会提出警告

#include <iostream>
using namespace std;
class A {
private:
	const int m_i;
};

int main()
{
	system("pause");
	return 0;
}