C++中类的静态成员变量和静态成员函数
C++中类的静态成员变量
以一个简单的例子来引入C++中类的静态成员变量!
假入客户给你提了一个需求:
- 统计在程序运行期间某个类的对象的数目
- 保证程序的安全性(不能使用全局变量)
- 随时可以获取当前对象的数目
你或许会想到用类的成员变量来做计数值。写出的代码可能类似下面的代码:
#include <stdio.h>
class Test
{
private:
int mCount;
public:
Test() : mCount(0)
{
mCount++;
}
~Test()
{
--mCount;
}
int getCount()
{
return mCount;
}
};
Test gTest; //一个全局对象
int main()
{
Test t1; //局部对象
Test t2; //局部对象
printf("count = %d\n", gTest.getCount());
printf("count = %d\n", t1.getCount());
printf("count = %d\n", t2.getCount());
return 0;
}
上面简单的代码用成员变量mCount作为计数值,在拷贝构造函数与析构函数中分别作自加与自减运算,看似当生成一个对象时,它的值就会加1,这样通过获取它的值就可以得知对象的数目。将代码放到linux下运行编译输出结果为:
count = 1
count = 1
count = 1
为什么跟我们预想的不一样呢?因为每个对象的成员变量都是每个对象专属的,我定义了三个对象,那么我这三个对象的成员变量都是自己专属的,其他对象的生成不会影响另一个对象的成员变量,而是调用该对象自己的成员变量,所以最终输出结果为三个1.
下面我们把计数值改为一个全局变量,试试看会出现什么结果呢?
#include <stdio.h>
int gCount;
class Test
{
private:
int mCount;
public:
Test() : mCount(0)
{
gCount++;
}
~Test()
{
--gCount;
}
int getCount()
{
return gCount;
}
};
Test gTest; //一个全局对象
int main()
{
Test t1; //局部对象
Test t2; //局部对象
printf("count = %d\n", gTest.getCount());
printf("count = %d\n", t1.getCount());
printf("count = %d\n", t2.getCount());
return 0;
}
这个时候的输出结果为:
count = 3
count = 3
count = 3
好,至少我们达到了第一步,实现了这个功能!但是呢,用户是有要求的,不能使用全局变量。因为全局变量在当代软件开发过程中是不受欢迎的,它是不够安全的!!!所以我们还是得想其他办法:普通成员变量无法满足,全局变量可以满足,综合他们两,我们可以用静态的成员变量!静态成员变量在文件内是全局属性的。在C++中我们可以定义静态成员变量:
- 静态成员变量属于整个类所有
- 静态成员的生命周期不依赖于任何对象(程序包运行的整个周期)
- 可以通过类名直接访问共有静态成员变量
- 所有对象共享类的静态成员变量
- 可以通过对象名访问公有静态成员变量
下面还是直接上代码分析比较直接:
#include <stdio.h>
class Test
{
private:
static int cCount;
public:
Test()
{
cCount++;
}
~Test()
{
--cCount;
}
int getCount()
{
return cCount;
}
};
int Test::cCount = 0; //这里是为什么?
Test gTest;
int main()
{
Test t1;
Test t2;
printf("count = %d\n", gTest.getCount());
printf("count = %d\n", t1.getCount());
printf("count = %d\n", t2.getCount());
Test* pt = new Test(); //发生了什么?
printf("count = %d\n", pt->getCount());
delete pt; //发生了什么?
printf("count = %d\n", gTest.getCount());
return 0;
}
输出结果为:
count = 3
count = 3
count = 3
count = 4
count = 3
下面我们来分析代码:这里static int cCount;定义的是一个静态成员变量,因为静态全局变量隶属于整个类所有,不隶属于某一个成对象,所以我们需要在类外单独给它分配空间,它位于全局数据区!!!这样在全局数据区给静态成员变量分配空间int Test::cCount = 0;
而这一段代码: Test* pt = new Test(); Test* pt = new Test();这里我们定义一个指针对象指向一个堆空间,那么它就会调用构造函数使得cCount加1,delete pt;调用析构函数,使得cCount减1。
由以上分析得出静态成员变量的几条特性:
- 在定义时直接通过static关键字修饰
- 静态成员变量需要在类外单独分配空间
- 静态成员变量在程序内部位于全局数据区(但是文件间无法共享)
单独分配空间的语法规则:
Type ClassName::VarName = value;
C++中类的静态成员函数
对于上面的最后一个版本(采用私有的static成员变量实现的)
很明显,我们获取对象的数目是需要调用getCount这个函数,每次调用都需要某一个对象来调用,比如:gTest.getCount(),那么问题来了,如果整个程序的对象的个数为0呢?那么岂不是没法调用getCount这个函数,也就没法知道对象的个数(别人是不知道你的对象的个数为0的)?
可不可以这样呢?我把静态成员变量cCount变为public,然后直接让Test(作用域调用)这个类来调用?先上一波代码看看:
#include <stdio.h>
class Test
{
public:
static int cCount;
public:
Test()
{
cCount++;
}
~Test()
{
--cCount;
}
int getCount()
{
return cCount;
}
};
int Test::cCount = 0;
int main()
{
printf("count = %d\n", Test::cCount);
//Test::cCount = 1000;
//printf("count = %d\n", Test::cCount);
return 0;
}
此代码与上面的代码的不同的是cCount变量变为public便于Test(作用域访问)类调用,没有任何的对象了,那么编译运行,输出结果应该是:
count = 0
说明这样做,符合了我们的需求了。但是,不要高兴的太早了,我们这样真的可以么?加入我把代码中的被注释的那两行加上(下面这两行):
Test::cCount = 1000;
printf("count = %d\n", Test::cCount);
再次运行会发生什么呢?我们编译运行,结果输出为:
count = 0
count = 1000
那么多问题来了,客户现在懵逼了,他会以为对象的个数有1000个,所以,这也是一个大的Bug啊,从本上讲,这样做也是无法满足客户的需求的,而且将cCount变为public,本身就是无法保证静态成员变量的安全性,我们需要什么?
- 不依赖对象就可以访问静态成员变量
- 必须保证静态成员变量的安全性
- 方便快捷得获取静态成员变量的值
那么静态成员函数就要出马了:
静态成员函数的定义:
直接通过static关键字修饰成员函数即可
为了便于理解,我们先上一段代码来理解一下静态成员函数的性质:
#include <stdio.h>
class Demo
{
private:
int i;
public:
int getI();
static void StaticFunc(const char* s);
static void StaticSetI(Demo& d, int v);
};
int Demo::getI()
{
return i;
}
void Demo::StaticFunc(const char* s)
{
printf("StaticFunc: %s\n", s);
}
void Demo::StaticSetI(Demo& d, int v)
{
d.i = v;
}
int main()
{
Demo::StaticFunc("main Begin...");
Demo d;
d.StaticSetI(d, 20);
printf("d.i = %d\n", d.getI());
Demo::StaticSetI(d, 10);
printf("d.i = %d\n", d.getI());
Demo::StaticFunc("main End...");
return 0;
}
以上代码运行的结果为:
StaticFunc: main Begin...
d.i = 20
d.i = 10
StaticFunc: main End...
由代码看到两个静态成员函数:
static void StaticFunc(const char* s);
static void StaticSetI(Demo& d, int v);
类调用静态成员函数:
Demo::StaticFunc("main Begin...");
对象调用静态成员函数:
d.StaticSetI(d, 20);
可以看出静态成员函数的性质大体如下:
- 静态成员函数是类中特殊的成员函数
- 静态成员函数属于整个类所有
- 可以通过类名(作用域访问)直接访问公有静态成员函数
- 可以通过对象名访问公有静态成员函数
而且通过这段代码:
void Demo::StaticSetI(Demo& d, int v)
{
d.i = v;
}
我么可以看出,静态成员函数,没有直接调用变量i,而是通过对象来间接调用变量i,这说明什么呢?
说明:
- 静态成员函数只能直接访问静态成员变量(函数),而不能直接访问普通成员变量(函数),但可以通过对象间接访问成员变量(函数)
下面做一个表格来对比一下静态成员函数与普通成员函数的区别:
好了,理解了静态成员函数,我们也应该来解决客户的需求了吧:直接上代码:
#include <stdio.h>
class Test
{
private:
static int cCount;
public:
Test()
{
cCount++;
}
~Test()
{
--cCount;
}
static int GetCount()
{
return cCount;
}
};
int Test::cCount = 0;
int main()
{
printf("count = %d\n", Test::GetCount());
Test t1;
Test t2;
printf("count = %d\n", t1.GetCount());
printf("count = %d\n", t2.GetCount());
Test* pt = new Test();
printf("count = %d\n", pt->GetCount());
delete pt;
printf("count = %d\n", Test::GetCount());
return 0;
}
运行结果为:
count = 0
count = 2
count = 2
count = 3
count = 2
分析: printf(“count = %d\n”, Test::GetCount());这段代码运行之前,没有创建对象,所以count = 0,
printf("count = %d\n", t1.GetCount());
printf("count = %d\n", t2.GetCount());
这两段代码运行之前已经创建了t1,t2这两个对象,所以都为:count = 2,
printf("count = %d\n", pt->GetCount());
这个运行之前又在堆空间创建了一个对象,并且让pt指针指向它,所以:count = 3
delete pt;
printf("count = %d\n", Test::GetCount());
在这两行先将pt指向的对象删除,所以最后是:count = 2
问题终于解决了!!!
总结:
- 静态成员函数是类中的特殊的成员函数
- 静态成员函数没有隐藏的this指针
- 静态成员函数可以通过类名直接访问
- 静态成员函数可以通过对象访问
- 静态成员函数只能直接访问静态成员变量(函数),而不能直接访问普通成员变量(函数)
this指针
如果对同一个类定义了n个对象,则有n组同样大小的空间以存放n个对象中的数据成员。但是,不同对象都调用同一个函数代码段。
那么,当不同对象的成员函数引用数据成员时,怎么能保证引用的是所指定的对象的数据成员呢?
这里就得this指针出马了
this指针是类的一个自动生成、自动隐藏的私有成员,它存在于类的非静态成员函数中,指向被调用函数所在的对象。全局仅有一个this指针,当一个对象被创建时,this指针就存放指向对象数据的首地址。
- 一个对象的this指针并不是对象本身的一部分,不会影响sizeof(对象)的结果。
- 全局函数,静态函数都没有this。
为什么 静态成员函数没有this指针
静态成员函数被所有的类对象所共享,就是说对同一个类定义了n个对象,这n个对象都调用同一个静态成员函数代码段(非静态成员函数也是被共享)。
静态成员变量也是被所有的类对象所共享,就是说对同一个类定义了n个对象,这n个对象都共共享同一个静态变量的内存区
静态成员函数只能直接访问静态成员变量(静态成员函数也能通过对象间接访问非静态成员变量),
这说明什么?
说明我们在用静态成员函数直接访问静态成员变量的时候,根本不需要this指针来区分同一个类定义的n个对象,因为这n个对象都共享同一个静态成员变量内存区。