【C++第七课】---类的静态成员

一、什么叫成员变量？

1.通过对象名能够访问 public 成员变量
2.每个对象都可以有只属于自己的成员变量
3.成员变量不能在对象之间共享

问题的引入---我们如何统计程序在运行期间有多少个对象同时存在呢？

使用普通的成员变量可以做到么？显然是不可以的，因为对象调用结束的时候成员变量是自动销毁了

所以，我们回忆一下C里面是怎么做的？对，就是静态成员变量和全局变量，但是在这里我们用全局

变量不合适，具体原因想必大家都知道，不详述。

二、什么叫做类的静态成员

1、在C++中可以定义静态成员变量和静态成员函数

1.静态成员属于整个类所有，不需要依赖任何对象
2.可以通过类名直接访问public 静态成员
3.可以通过对象名访问public 静态成员
4.静态成员函数可以直接访问静态成员变量（非静态成员函数也可以直接访问静态成员变量）

2、静态成员变量的定义

在定义时直接通过static关键字修饰
―静态成员变量不依赖于任何对象，，需要在类外单独分配空间
―语法规则：：Type ClassName::VarName ；

3、静态成员函数的定义

在定义时直接通过static关键字修饰
―其余部分与普通成员函数定义相同

三、静态成员类得个示例

#include <iostream>

using namespace std;

class Test
{
	private:
		static int mI;				//声明
	public:
		int Get_I();				//声明
		void Set_I(int);			//声明
};

int Test::mI = 1;					//定义
int Test::Get_I()					//定义
{
		cout<<"mI = "<<mI<<endl;
		return mI;
}
void Test::Set_I(int i)					//定义
{
		mI = i;
}
int main(int argc, char** argv)
{
	Test T1;
	T1.Set_I(2);
	T1.Get_I();
	return 0;	
}

上述程序很容易分析得到结果是

mI = 2

对类得静态成员总结如下：

从命名空间的角度

1.类的静态成员只是类这个命名空间中的全局变量和全局函数
2.不同之处只是，类可以对静态成员进行访问权限的限制 ，而命名空间不行

从面向对象的角度
1.类的静态成员属于类概念本身
2.类的所有对象共享相同的静态成员

四、问题的解决

上面我们提到了如何解决统计对象数目的问题，下面我们使用静态成员来解决这个问题

代码如下：

#include <iostream>

using namespace std;

class Test
{
	private:
		static int mCount;				//声明
	public:
		static int Get_I();				//注意一定要声明为static类型
		void Set_I(int);				//声明
		Test()
		{
			mCount ++;	
		}
		~Test()
		{
			mCount --;	
		}
};

int Test::mCount = 1;						//定义
int Test::Get_I()						//定义的时候不需要加上static
{
		cout<<"mCount = "<<mCount<<endl;
		return mCount;
}
void Test::Set_I(int i)						//定义
{
		mCount = i;
}

void run(void)
{
	Test T[100];
	cout<<"the number of class is "<<Test::Get_I()<<endl;	//访问的时候使用：：访问符号
}
int main(int argc, char** argv)
{
	Test T1;
	Test T2;
	cout<<"the number of class is "<<Test::Get_I()<<endl;
	run();
	cout<<"the number of class is "<<Test::Get_I()<<endl;
	return 0;	
}

上述代码仔细分析可得到如下结果

mCount = 3
the number of class is 3
mCount = 103
the number of class is 103
mCount = 3
the number of class is 3

五、初步探讨C++对象模型

先来一个例子

#include <iostream>

using namespace std;

struct Test1
{
	int i;	
	int j;
	short m;
	short n;
	double h;
	double k;
};
struct Test2
{
	int i;	
	int j;
	short m;
	short n;
	double h;
	double k;
};
struct Test3
{
	int i;	
	int j;
	short m;
	short n;
	double h;
	double k;
	int fun()
	{
		m = n;
		i = j;	
	}
};

int main(int argc, char** argv)
{
	cout<<"sizeof(Test1) = "<<sizeof(Test1)<<endl;
	cout<<"sizeof(Test2) = "<<sizeof(Test2)<<endl;
	cout<<"sizeof(Test3) = "<<sizeof(Test3)<<endl;
	return 0;	
}

gcc环境下编译运行结果如下：

sizeof(Test1) = 28
sizeof(Test2) = 28
sizeof(Test3) = 28

没错，这里涉及到字节对齐和成员变量/成员函数 存储的问题，前者不详述，对后者进行简单的说明

1、C++类对象中的成员变量和成员函数是分开存储的
1.成员变量
―普通成员变量：存储于对象中，struct变量有相同的
内存布局和字节对齐方式
―静态成员变量：：存储于全局数据区中
2.成员函数
―存储于代码段

2、静态成员函数与普通成员函数的区别

静态成员函数不包含指向具体对象的指针
普通成员函数包含一个指向具体对象的指针
C++ C++中类的普通成员函数都隐式包含
一个指向当前对象的this指针。

六、最后做个小结

1、C++类中可以包含属于类概念的静态成员 类中可以包含属于类概念的静态成员
2、静态成员变量在全局数据区分配空间
3、静态成员函数不包含隐藏的this指针
4、通过类名可以直接访问静态成员
5、通过对象名可以访问静态成员，，所有的对象可以共享 所有的对象可以共享同一个类的静态成员