c++this指针

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>
#include<vector>

using namespace std;

class AA
{
public:
    AA(int a, int b)
    {
        my_a = a;
        my_b = b;
    }
    int getA()//这儿相当于int getA(AA *this)，this为指向对象的指针，只不过可以省略，编译器会自己帮我们添加
    {
        //下面一段代码等价于return this->my_a，this是一个指针，指向的就是创建的对象整体
        return my_a;
    }
private:
    int my_a;
    int my_b;
};

class Test
{
public:
    Test(int t)
    {
        //this指针是Test *const this（const看右面，离谁近就修饰谁），这表明指针this指向的空间内容可以修改，但指针本身不可以被修改，因此this是一个常指针，不可被修改
        this->my_t = t;
    }
    int getT() const//函数后面加const关键词修饰的是this指针，虽然this指针被隐藏了，函数从来不会被const修饰，函数后面加const表示这个指针指向空间的内容也不能被修改了
    {
        //this->my_t = 199;这段代码是错误的，因为const修饰了this指针，使this指向空间的内容也不允许被修改了
        return this->my_t;
    }
    static void function()
    {
        //为什么静态函数只能调用静态变量的根本原因L：
        //因为静态方法中不存在隐式的this指针，它不属于某个对象，它属于一个类，属于这个类的所有对象
    }
    
private:
    int my_t;
};

class Group
{
public:
    Group(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    int getA()
    {
        //类中的方法关于类内部变量的调用尽量用this表示，这样会增加代码的可读性，加this的一看就知道调用的变量是在类的内部的
        return this->a;
    }
    int getB()
    {
        return this->b;
    }
    //因为已经创建了对象，要依赖对象再建另外一个对象，这是没有办法直接使用构造函数建立的，只能使用成员方法进行，再成员方法里在调用构造函数创建新的对象
    Group groupAdd(Group &another)
    {
        //这里有两个对象，一个是调用这个方法的对象，this为其指针，一个是函数参数传进来的对象，another为其引用
        Group group(this->a + another.a, this->b + another.b);//因为在相同类的内部，所以可以直接调用私有变量
        return group;//这里应也是返回匿名对象
    }
    //返回对象的本身，其实这个对象内容本来已经被修改过了，并不需要返回干什么，但是为了可以直接实现连加，即出现+=的效果，所以需要返回对象本身
    //返回对象本身，一定只能用引用
    Group &groupSelf(Group &another)
    {
        this->a += another.a;
        this->b += another.b;
        return *this;//return *this指返回this指针指向区域的内容，即返回对象本身，如果return this则表明返回的是对象的指针，需要用对象的指针去接收，应也可以实现连加效果，但此时不是返回对象本身可，而是返回对象的指针
    }
    void printG()
    {
        cout << "a=" << a << endl;
        cout << "b=" << b << endl;
    }
private:
    int a;
    int b;
};

//全局函数，使对象g1和g2相加生成另一个对象
Group groupAdd(Group &g1, Group &g2)
{
    //调用显式构造函数，创建对象g3，里面的参数为对象g1和g2相加
    Group g3(g1.getA() + g2.getA(), g1.getB() + g2.getB());

    return g3;//这里是调用拷贝构造函数，返回了一个匿名对象，并不是对象g3
}

int main()
{
    AA a1(1, 2);//调用构造函数也是一样，编译器会自动帮我们把a1的地址传给构造函数，即等价于AA(&a1, 1, 2)，所以初始化的数据一定只会传给对象a1
    AA a2(2, 3);

    //方法不是存在对象内部空间的，那么为什么a1.getA()返回的是对象a1的变量my_a而不是对象a2的变量my_a
    //因为下面一段代码a1.getA()等价于getA(&a1)，是把对象a1的地址传给了函数，因此一定不会返回错误
    //总结：对象在调用方法时，不论是普通函数还是构造函数，都会隐式的把存有自己地址的指针传递进去，这样可以使方法唯一确定执行操作的位置
    a1.getA();

    Group g1(1, 2);
    Group g2(3, 4);
    //使用类外部的全局函数进行创建
    Group g3 = groupAdd(g1, g2);
    //对象调用内部方法构建另一个对象
    Group g4 = g1.groupAdd(g2);

    //下面一段代码的过程为：函数groupAdd()通过参数创建一个新的对象，这个对象再返回的时候会被调用拷贝构造函数构造一个匿名对象，然后这个对象被回收，匿名对象被返回，匿名对象再调用getA()方法获得匿名对象里私有成员a的值
    //返回引用时，引用的变量没被回收时可以做左值的，被回收是不能做左值的
    //一般变量被返回时，不会也没有拷贝构造匿名对象，直接用来赋值就可以，赋值完以后变量就会被回收
    int a = groupAdd(g2, g3).getA();//方法一定不能忘记()括号，不然会报错误


    Group g5(1, 1);
    Group g6(1, 1);

    //下面四段代码都可以实现连加效果，但前两段代码每次都会新建一个匿名对象，最后返回的是最后一个创建的匿名对象，这个匿名对象把前几个对象的值都加起来了
    Group g7 = g5.groupAdd(g1).groupAdd(g2).groupAdd(g3);
    g7.printG();
    //下面两段代码也可以实现连加效果，但这不会创建匿名对象，且结果都是存储在主对象g5中的，每次都会返回g5对象本身，在把g5和参数对象传进去，实现连加效果，即+=
    g5.groupSelf(g1).groupSelf(g2).groupSelf(g3);
    g5.printG();


    //only test,please ignore
    /*
    int nums[100];
    int b = sizeof(nums);//sizeof计算出来的是整个数组占多少，即100*int;
    cout << "sizeof=" << b << endl;
    vector<int> nums(10);
    int c = sizeof(nums);//但容器的大小不可以用sizeof计算，应用nums.size()计算,计算出来的结果是这个容器中含有多少个元素，即元素个数
    cout << "sizeof=" << c << endl;
    for (int i=0; i < 10; i++)
    {
        if (i <= 0)
        {
            cout << "============================" << endl;
            break;
        }
    }
    /*
    int c;
    vector<int> nums(10);
    cout << "sizeof=" << nums.size() << endl;
    char s[] = "hello";
    cout << "strlen=" << strlen(s) << endl;//结果为5，不算\0的位置
    cout << "sizeof=" << sizeof(s) << endl;//结果为6，算\0的位置
    const char *str = "hello";
    char buf[64] = "hello";
    if (strcmp(str, buf) == 0)//是相等的
    {
        cout << "==============================" << endl;
    }
    */
    return 0;
}