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 = %dn", gTest.getCount());
    printf("count = %dn", t1.getCount());
    printf("count = %dn", 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 = %dn", gTest.getCount());
    printf("count = %dn", t1.getCount());
    printf("count = %dn", 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 = %dn", gTest.getCount());
    printf("count = %dn", t1.getCount());
    printf("count = %dn", t2.getCount());
    
    Test* pt = new Test();    //发生了什么？
    
    printf("count = %dn", pt->getCount());
    
    delete pt;                //发生了什么？
    
    printf("count = %dn", 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 = %dn", Test::cCount);
    
    //Test::cCount = 1000;
    
    //printf("count = %dn", Test::cCount);
    
    return 0;
}

此代码与上面的代码的不同的是cCount变量变为public便于Test（作用域访问）类调用，没有任何的对象了，那么编译运行，输出结果应该是：
count = 0

说明这样做，符合了我们的需求了。但是，不要高兴的太早了，我们这样真的可以么？加入我把代码中的被注释的那两行加上（下面这两行）：

Test::cCount = 1000;
printf("count = %dn", 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: %sn", 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 = %dn", d.getI());
    
    Demo::StaticSetI(d, 10);
    
    printf("d.i = %dn", 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，这说明什么呢？
说明：

1. 静态成员函数只能直接访问静态成员变量（函数），而不能直接访问普通成员变量（函数），但可以通过对象间接访问成员变量（函数）
   下面做一个表格来对比一下静态成员函数与普通成员函数的区别：
   
   好了，理解了静态成员函数，我们也应该来解决客户的需求了吧：直接上代码：

#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 = %dn", Test::GetCount());
    
    Test t1;
    Test t2;
    
    printf("count = %dn", t1.GetCount());
    printf("count = %dn", t2.GetCount());
    
    Test* pt = new Test();
    
    printf("count = %dn", pt->GetCount());
    
    delete pt;
    
    printf("count = %dn", Test::GetCount());
    
    return 0;
}

运行结果为：

count = 0
count = 2
count = 2
count = 3
count = 2

分析： printf(“count = %dn”, Test::GetCount());这段代码运行之前，没有创建对象，所以count = 0，

printf("count = %dn", t1.GetCount());
printf("count = %dn", t2.GetCount());

这两段代码运行之前已经创建了t1，t2这两个对象，所以都为：count = 2，

printf("count = %dn", pt->GetCount());

这个运行之前又在堆空间创建了一个对象，并且让pt指针指向它，所以：count = 3

delete pt;
    
printf("count = %dn", 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个对象都共享同一个静态成员变量内存区。

最后

以上就是淡然眼睛为你收集整理的C++中类的静态成员变量和静态成员函数C++中类的静态成员变量C++中类的静态成员函数this指针为什么 静态成员函数没有this指针的全部内容，希望文章能够帮你解决C++中类的静态成员变量和静态成员函数C++中类的静态成员变量C++中类的静态成员函数this指针为什么 静态成员函数没有this指针所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。