C++ Static成员

什么是static

static 是 C/C++ 中很常用的修饰符，它被用来控制变量的存储方式和可见性。

static关键字的引入

我们知道在函数内部定义的变量，当程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义为全局的变量，但定义一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅只受此函数控制）。static 关键字则可以很好的解决这个问题。另外，在 C++ 中，需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见时，可将其定义为静态数据。

---

静态数据的存储

在 C++ 中 static 的内部实现机制：静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。

静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的"尺寸和规格"，并不进行实际的内存分配，所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。

---

static的使用

1. 声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；
2. 用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进
   行初始化

通过类名调用静态成员函数和非静态成员函数:

结论1：不能通过类名来调用类的非静态成员函数。
通过类的对象调用静态成员函数和非静态成员函数。

class Point  
{  
public:   
    void init()  
    {    
    }  
    static void output()  
    {  
    }  
};  
void main()  
{  
    Point::init();  //错误，类的非静态成员函数需要通过对象调用 
    //静态成员函数的第一种调用方法：类名::成员函数
    Point::output();  //正确，静态成员不属于任何对象，是属于类的，所以只需要声明类域调用
}

结论2：类的对象可以使用静态成员函数和非静态成员函数。
在类的静态成员函数中不可以使用类的非静态成员变量。

#include <iostream>  
class Point  
{  
public:   
    void init()  
    {    
    }  
    static void output()  
    {  
    	//错误：因为静态成员函数没有this指针，所以不知道调用的对象是哪一个，自然也就无法访问非静态成员变量了
        cout << m_x << endl;  
    }  
private:  
    int m_x;  
};  
int main()  
{  
	//创建对象
    Point pt;  
    //静态成员函数的第二种调用方法：对象名.成员函数
    pt.output();  
}

结论3：在类的非静态成员函数中使用类的静态成员函数。

class Point  
{  
public:   
    void init()  
    {    
        output();  
    }  
    static void output()  
    {  
    	cout << "static void output()" << endl;
    }  
};  
int main()  
{  
	//创建对象
    Point pt;  
    //正常调用非静态成员函数
    Pt.init();      //正确
    //使用对象名都调用静态成员函数
    pt.output();   //正确
}

结论4：类的非静态成员函数可以调用用静态成员变量，但反之不能。

#include <iostream>  
class Point  
{  
public:   
	//构造函数
    Point()  
    {    
        m_nPointCount++;  
    }  
    
    //析构函数
    ~Point()  
    {  
        m_nPointCount--;  
    }  
    static void output()  
    {  
        cout << m_nPointCount << endl; 
    }  
private:  
    static int m_nPointCount;  
};  
int main()  
{  
	//创建对象
    Point pt;  
    pt.output();  
}

出现错误的原因是：静态变量静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

static关键字的小场景

实现一个类，计算程序中创建出了多少个类对象
我们通常的做法是使用一个全局变量

//我们通常的做法是使用一个全局变量
#include <iostream>
using namespace std;

int _scount = 0;
class A
{
public:
	//构造函数
	A()
	{
		++_scount;
	}

	//拷贝构造
	A(const A& t)
	{
		++_scount;
	}

	//析构函数
	~A()
	{
		--_scount;
	}

	static int GetACount()
	{
		return _scount;
	}

};

int main()
{
	cout << _scount << endl;
	A a1, a2;
	A a3(a1);
	cout << _scount << endl;
	return 0;
}

考虑到封装的问题，我们使用static修饰的变量

#include <iostream>
using namespace std;
 
class A
{
public:
	//构造函数
	A() 
	{ 
		++_scount; 
	}

	//拷贝构造
	A(const A & t) 
	{ 
		++_scount; 
	}

	//析构函数
	~A() 
	{ 
		--_scount; 
	}

	static int GetACount() 
	{ 
		return _scount; 
	}

private:
	static int _scount;
};

//必须在类外进行定义初始化
int A::_scount = 0;
int main()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
	return 0;
}