【C++面向对象】三、this指针

文章目录

三、this指针

1、this是什么

在C++中，this是一个指针，用来指向当前的对象的！

class Person {
public:
    Person() {}
    Person(int a): age(a) {}

    int getAge() {
        return age;
    }

private:
    int age;
}

在上述代码中，类Person中有一个函数getAge，可以返回属性age的值。那么问题来了，一个类可以有多个对象的。而非静态的属性age是隶属于对象的。不同的对象的age，在内存中的空间肯定也是不同的。如何区分需要返回哪一个对象的age呢？

在一个类中，涉及到成员的访问的时候，非静态的成员访问，通常都会使用this指针来访问。

class Person {
public:
    Person() {}
    Person(int a): age(a) {}

    // 这里使用this指针来访问age属性，这种写法是默认的，并且this是可以省略不写的
    // 那么所谓的当前对象到底是谁呢？
    // 最简单的理解就是：哪个对象调用这个函数，this指针就指向谁
    int getAge() {
        return this->age;
    }

private:
    int age;
}

2、this不可省略的情况

绝大多数的情况下，在一个类的内部，访问当前类中的非静态成员的时候，this指针都是可以省略不写的。但是有一种情况，this指针不能省略，必须要显式的写出来：

如果在一个函数中出现了与当前类的属性同名字的局部变量！为了区分局部变量还是属性，此时的this指针不能省略。

class Person {
public:
    int age;

    // 在这个构造函数中，出现了一个局部变量age，与属性名字相同了
    // 于是为了区分这两个，需要使用this指针显式的指向age属性来进行访问
    Person(int age) {
        this->age = age;
    }
}

3、返回当前对象的函数

class Point {
public:
    int x;
    int y;
    Point() {}
    Point(int x, int y): x(x), y(y) {}

    // 返回当前对象的引用
    Point& add(int deltaX, int deltaY) {
        x += deltaX;
        y += deltaY;
        // this是一个指针，用来指向当前的对象
        // 因此，如果需要返回当前的对象的话，就需要使用*来访问
        return *this;
    }
}

4、空指针访问成员函数

在C++中，使用空指针是可以访问成员函数的，但是需要注意：不能在函数中出现this指针！

class Person {
public:
    int age;

    Person() {}
    Person(int age): age(age) {}

    void testFunction01() {
        cout << "testFunction01执行了" << endl;
    }

	void testFunction02() {
	    if (this == NULL) {
	        cout << "this是一个空指针" << endl;
	        return;
	    }
	    cout << "testFunction02执行了" << endl;
	}
	
	void getAge() {
	    return age;
	}
}

int main() {
    // 创建一个空对象
    Person* person = NULL;

    // 函数访问
    person->testFunction01();       // 可以正常访问，因为在这个函数中没有使用到this指针
    person->testFunction02();       // 访问出问题，因为在这个函数中使用到了this指针
    person->getAge();               // 访问出问题，在这个函数中虽然没有写this，但是有属性的访问，默认就是用到的this

    return 0;
}

5、常函数与常对象

5.1、什么是常函数

• 使用关键字const修饰的函数，叫做常函数。
• 常函数中，不允许修改属性的值。
• 常函数中，不允许调用其他的普通函数。
• 如果想要在常函数中修改某个属性的值，需要将这个属性设置为mutable。

class Person {
public:
    string name;
    int age;
    mutable int score;             // 修饰为可变的，这个属性可以在常函数中进行修改

    Person(string name, int age, int score): name(name), age(age), score(score) {}

    // 定义常函数
    void fixPerson(string newName, int newAge, int newScore) const {
        name = newName;            // 这里会出错，不允许在常函数中修改普通属性的值
        age = newAge;              // 这里会出错，不允许在常函数中修改普通属性的值
        score = newScore;          // 这里可以正常修改，因此此时的score已经被修饰为mutable
 
		test();     // 这里会出错，不允许在常函数中调用其他的普通函数
	}

	void test() {}
}

5.2、常对象

• 在对象创建的时候，使用const修饰的对象，就是常对象。
• 常对象可以访问任意的属性值，但是不能修改普通属性的值。
• 常对象可以修改mutable属性的值。
• 常对象只能调用常函数。

int main() {
    // 创建一个常对象
    const Person person("zhangsan", 18, 99);

    // 使用这个常对象进行属性访问
    cout << person.name << endl;       // 可以正常访问
    person.age = 100;                  // 不能进行修改
    person.score = 200;                // mutable属性，可以修改
}