题解 | this->的应用 | 点和圆的关系

#include <iostream>
using namespace std;

// 点类
class Pointer {

    private:
        int x;  // x 坐标
        int y;  // y 坐标

    public:
        void setX(int x) {
            this->x = x;
        }

        int getX() {
            return x;
        }

        void setY(int y) {
            this->y = y;
        }

        int getY() {
            return y;
        }

};

// 圆类
class Circle {

    private:
        Pointer center; // 圆心
        int radius; // 半径

    public:
        void setCenter(int x, int y) {
            center.setX(x);
            center.setY(y);
        }

        void setRadius(int radius) {
            this->radius = radius;
        }

        // write your code here......
        void isPointerInCircle(class Pointer p){

            int cx = center.getX();
            int cy = center.getY();
            int x = p.getX();
            int y = p.getY();
            // 3. 计算点到圆心的距离平方（避免浮点运算）
            long long distSq = (long long)(x - cx) * (x - cx) + (long long)(y - cy) * (y - cy);
            long long rSq = (long long)radius * radius;
            // 4. 正确判断位置关系
            if (distSq < rSq) {
                cout << "in";
            } else if (distSq == rSq) {
                cout << "on";
            } else {
                cout << "out";
            }
        }
        

};

int main() {

    // 键盘输入点的坐标
    int x, y;
    cin >> x;
    cin >> y;

    // 创建一个点
    Pointer p;
    p.setX(x);
    p.setY(y);

    // 创建一个圆
    Circle c;
    c.setCenter(5, 0);
    c.setRadius(5);

    // 判断点和圆的关系
    c.isPointerInCircle(p);

    return 0;
}

一、先搞懂核心：this 指针是什么？

在 C++ 中，每个非静态的成员函数（比如 setRadius）都会隐含一个名为 this 的指针，这个指针的核心作用是：👉 指向「调用该成员函数的那个对象本身」。

可以用大白话理解：把类的对象想象成一个“房子”，成员函数是“房子里的操作”，this 就是房子门上的“我家”标签 —— 函数里通过 this，能精准找到“当前操作的是哪一个房子（对象）”的成员变量/函数。

this 的本质是一个常量指针（类名* const），比如在 Circle 类的成员函数里，this 的类型是 Circle* const：

• const 表示 this 不能指向其他对象（只能指向调用函数的那个对象）；
• this 指向的是对象的首地址，通过 -> 可以访问对象的成员。

二、为什么需要 this->radius = radius;？（核心解决「命名冲突」）

先看你的代码场景：

class Circle {
private:
    int radius; // 成员变量：圆的半径（属于Circle对象）
public:
    void setRadius(int radius) { // 形参：传入的半径值（局部变量）
        this->radius = radius; 
    }
};

这里有两个同名的 radius：

1. 成员变量：Circle 类定义的 private int radius（属于对象的“自有属性”）；
2. 函数形参：setRadius 的参数 int radius（函数的“局部变量”）。

问题：如果直接写 radius = radius; 会怎样？

编译器遵循「局部优先」原则 —— 会把等号两边的 radius 都识别为函数形参（局部变量），相当于“把形参赋值给形参自己”，而对象的成员变量 radius 完全没被修改，这就会导致赋值失效！

解决方案：用 this-> 区分「成员变量」和「局部变量」

• this->radius：明确告诉编译器 —— 我要访问「当前对象」的成员变量 radius（房子里的自有家具）；
• 等号右边的 radius：编译器识别为函数的形参（外面拿来的东西）；
• 整句话的意思：把传入的形参值，赋值给调用该函数的Circle对象的radius成员变量。

三、逐字拆解 this->radius = radius;

举个具体调用例子：

int main() {
    Circle c;
    c.setRadius(5); // 调用c的setRadius，传入参数5
    return 0;
}

执行 c.setRadius(5) 时：

1. this 指针指向对象 c；
2. this->radius 就是 c.radius（c 的成员变量）；
3. 等号右边的 radius 是传入的 5；
4. 最终：c.radius = 5（正确给 c 的半径赋值）。

四、补充：什么时候可以不用 this->？

如果成员变量和局部变量名字不同，编译器能区分，就可以省略 this->：

class Circle {
private:
    int radius;
public:
    // 形参名改成r，和成员变量不重名
    void setRadius(int r) {
        radius = r; // 编译器能识别：radius是成员变量，r是形参，无需this->
    }
};

这种写法和 this->radius = r; 效果完全一样，只是前者依赖“命名不冲突”，后者更显式（推荐写 this->，代码可读性更高，尤其是复杂类）。

五、this 的其他重要特性（新手必知）

1. this 是隐含的，无需定义：成员函数里可以直接用 this，不用自己声明（编译器自动传入）；
2. this 不能修改指向：this 是 Circle* const 类型，比如不能写 this = &otherCircle;（编译报错）；
3. 静态成员函数没有 this：静态函数属于“类本身”，不属于某个对象，所以没有 this 指针（也不能访问非静态成员）；
4. this 可以解引用：*this 表示当前对象本身，比如想返回当前对象时可以写 return *this;（常用于链式调用）。

链式调用例子（拓展）：

class Circle {
private:
    int radius;
public:
    Circle& setRadius(int radius) { // 返回当前对象的引用
        this->radius = radius;
        return *this; // *this 是当前对象，返回引用可以链式调用
    }
    Circle& setCenter(int x, int y) {
        // ... 你的setCenter逻辑
        return *this;
    }
};

// 链式调用：一行代码完成多个赋值
int main() {
    Circle c;
    c.setRadius(5).setCenter(5, 0); // 先设半径，再设圆心
    return 0;
}

六、总结

this->radius = radius; 的核心作用是：✅ 解决「成员变量名」和「函数局部变量名」的命名冲突；✅ 通过 this 指针精准访问「当前调用函数的对象」的成员变量；

记住两个关键：

1. this 指向“当前对象”；
2. this->成员名 明确访问对象的成员，而非局部变量。

这是 C++ 类和对象的基础语法，也是面试高频考点（比如问 this 指针的作用、this 和 -> 的用法），吃透这个例子，类的成员访问就彻底懂了！