C++学习：this指针

this指针

类的对象有成员变量和成员函数构成，从程序运行的角度，独享是由数据和函数构成的，数据可以位于栈、堆、全局数据区；函数只能位于代码段，所有的对象共享一套成员函数。

成员函数能直接访问对象的属性（成员变量），是因为成员函数中有一个隐藏参数this指针，用于指代当前的对象。

#include 
 
using namespace std;
 
class Test
{
private:
    int mi;
 
public:
    //有参构造函数
    Test(int i)
    {
       mi = i;
    }
 
    //拷贝构造函数
    Test(const Test& t)
    {
 
    }
 
    //返回mi
    int getMi()
    {
        return mi;
    }
 
    //打印this指针
    void print()
    {
        cout << "this = " << this << endl;
    }
 
};
 
 
int main()
{
    Test t1(1);
    Test t2(2);
    Test t3(3);
    cout << "t1.getMi() = " << t1.getMi() << endl;
    cout << "&t1 = " << &t1 << endl;
    t1.print();
    cout << endl;
 
    cout << "t2.getMi() = " << t2.getMi() << endl;
    cout << "&t2 = " << &t2 << endl;
    t2.print();
    cout << endl;
 
    cout << "t3.getMi() = " << t3.getMi() << endl;
    cout << "&t3 = " << &t3  << endl;
    t3.print();
    cout << endl;
 
 
    return 0;
}

输出结果

t1.getMi() = 1
&t1 = 0x64fe0c
this = 0x64fe0c
 
t2.getMi() = 2
&t2 = 0x64fe08
this = 0x64fe08
 
t3.getMi() = 3
&t3 = 0x64fe04
this = 0x64fe04

结果分析：

通过结果可以看出打印的this指针与对象的地址是一样的，这个this指针是一个隐藏的参数。

静态成员变量

我们知道对象的成员变量一般不能被外界所访问，每个对象有自己独立的一套成员变量，那有没有可能在类中高一个成员变量，让所有对象共享这个成员变量，这就需要静态成员变量。

静态成员变量的特征：

1、静态成员变量属于整个类所有，而不是某个对象；

2、静态成员变量的生命周期不依赖于任何对象；

3、可以通过类名直接访问公有的静态成员变量；

4、所有对象共享类的静态成员变量；

5、可以通过对象名访问公有的静态成员变量；

6、静态成员变量需要再类的外面单独分配空间；

7、静态成员变量在程序内部位于全局数据区；

静态成员变量的

比如要统计在程序运行期间某个类的对象数目，不使用全局变量，还要随时获取当前类对象的数目。可以通过下面的代码来实现

头文件 

#ifndef COUNT_H
#define COUNT_H
 
class Count
{
private:
    static int mCount; //定义一个静态成员变量
public:
    Count();
    ~Count();
    int getCount();
};
 
#endif // COUNT_H

 源文件

#include "count.h"
 
//用初始化列表将mCount初始化为0
Count::Count()
{
    mCount++; //每定义一个对象，就会调用构造函数
}
 
 
Count::~Count()
{
    mCount--;//每删除一个对象，就会调用析构函数
}
 
//返回在运行的对象数目
int Count::getCount()
{
    return mCount;
}

 应用

#include 
#include "count.h"
using namespace std;
 
Count gc; //定义一个全局对象
 
int Count::mCount = 0; //静态成员变量初始化
 
int main()
{
    Count c1; //定义一个局部对象
    Count c2;//定义一个局部对象
 
    cout << gc.getCount() << endl; //应该输出3
    cout << c1.getCount() << endl; //应该输出3
    cout << c2.getCount() << endl; //应该输出3
 
    Count* pt = new Count();
    cout << pt->getCount() << endl; //应该输出4
 
    delete pt;
    cout << gc.getCount() << endl; //应该输出3
 
 
    return 0;
}

静态成员函数

上面的代码能实现：

1、统计程序运行期间类的对象的数目；

2、不使用全局变量

但是不能实现随时获取对象的数目

每次获取对象数目的时候都需要调用getCount()这个函数，但是如果程序中一个对象都没有定义，也应该能获取对象的数目是0，但是对象都没有了，怎么调用getCount()这个函数？

我们需要不依赖对象就可以访问静态成员变量，还要保证静态成员变量的安全性，此时就需要静态成员函数，静态成员函数有如下特征：

1、静态成员函数时类中特殊的成员函数；

2、静态成员函数属于整个类所有；

3、可以通过类名直接访问公有的静态成员函数；

4、可以通过对象名访问公有的静态成员函数。

5、静态成员函数可以通过类名直接访问；

6、静态成员函数只能直接访问静态成员变量。

将关键字static加在成员函数前就变成静态成员函数了。

修改上面代码的头文件，就是在int getCount()前面加个static；

#ifndef COUNT_H
#define COUNT_H
 
class Count
{
private:
    static int mCount; //定义一个静态成员变量
public:
    Count();
    ~Count();
    static int getCount(); //声明静态成员函数
};
 
#endif // COUNT_H

应用代码，使用类名来调用静态成员函数，不依赖于特定的对象。

#include 
#include "count.h"
using namespace std;
 
 
int Count::mCount = 0; //静态成员变量初始化
 
int main()
{
    //通过类名来调用静态成员函数
    cout << Count::getCount() << endl; //应该输出0
    Count c1; //定义一个局部对象
    Count c2;//定义一个局部对象
 
    cout << Count::getCount() << endl; //应该输出2
 
 
    Count* pt = new Count();
    cout << Count::getCount() << endl; //应该输出2
 
    delete pt;
 
    return 0;
}

这样，统计在程序运行期间某个类的对象数目的代码就结束了，满足全部需求。