第三节 · 询问自己 · this指针

当我们在类的成员函数中访问成员变量时，有没有想过一个问题：函数是怎么知道要访问哪个对象的成员的？

class Counter
{
public:
    int value = 0;
    
    void increment()
    {
        value++;  // 这个 value 是哪个对象的？
    }
};

int main()
{
    Counter c1, c2;
    c1.increment();  // 增加 c1 的 value
    c2.increment();  // 增加 c2 的 value
    return 0;
}

答案是 this 指针。

---

什么是 this

this 是一个隐含的指针，指向调用成员函数的那个对象。每个非静态成员函数都有一个隐含的 this 参数。

class Counter
{
public:
    int value = 0;
    
    void increment()
    {
        this->value++;  // 显式使用 this
        // 等价于：value++;
    }
    
    void print()
    {
        cout << "value = " << this->value << endl;
        // 等价于：cout << "value = " << value << endl;
    }
};

当你写 c1.increment() 时，实际上编译器会把它转换成类似这样的调用：

increment(&c1);  // 将 c1 的地址作为 this 传递

---

this 的类型

对于类 T 的非 const 成员函数，this 的类型是 T*。 对于 const 成员函数，this 的类型是 const T*。

class Example
{
public:
    void func()
    {
        // this 的类型是 Example*
    }
    
    void constFunc() const
    {
        // this 的类型是 const Example*
        // 不能通过 this 修改成员
    }
};

---

this 的用途

1. 解决命名冲突

当参数名与成员名相同时，可以用 this 区分：

class Person
{
private:
    string name;
    int age;
    
public:
    void setInfo(const string& name, int age)
    {
        this->name = name;  // this->name 是成员，name 是参数
        this->age = age;
    }
};

2. 返回对象自身的引用

这是实现链式调用的关键：

class Builder
{
private:
    string result;
    
public:
    Builder& append(const string& s)
    {
        result += s;
        return *this;  // 返回自身的引用
    }
    
    Builder& appendLine(const string& s)
    {
        result += s + "\n";
        return *this;
    }
    
    string build() const
    {
        return result;
    }
};

int main()
{
    Builder b;
    string text = b.append("Hello")
                   .appendLine(" World!")
                   .append("How are you?")
                   .build();
    
    cout << text << endl;
    // 输出:
    // Hello World!
    // How are you?
    
    return 0;
}

3. 将对象自身传递给其他函数

class Node
{
public:
    int value;
    
    void registerWithManager(Manager& manager)
    {
        manager.addNode(this);  // 将自己的指针传递出去
    }
};

4. 在成员函数中创建自身的副本

class Widget
{
public:
    int data;
    
    Widget clone() const
    {
        return *this;  // 返回自身的副本
    }
};

---

this 与 const 成员函数

在 const 成员函数中，this 是 const T* 类型，这意味着：

class Example
{
public:
    int value;
    
    void modify()
    {
        value = 10;  // OK
    }
    
    void tryModify() const
    {
        // value = 10;  // 错误！const 成员函数不能修改成员
    }
    
    int getValue() const
    {
        return value;  // OK，只读取
    }
};

---

链式调用的实际应用

链式调用在很多场景下都很有用：

class Query
{
private:
    string table;
    string conditions;
    string orderBy;
    int limitCount = -1;
    
public:
    Query& from(const string& tableName)
    {
        table = tableName;
        return *this;
    }
    
    Query& where(const string& condition)
    {
        if (!conditions.empty())
            conditions += " AND ";
        conditions += condition;
        return *this;
    }
    
    Query& order(const string& column)
    {
        orderBy = column;
        return *this;
    }
    
    Query& limit(int count)
    {
        limitCount = count;
        return *this;
    }
    
    string build() const
    {
        string sql = "SELECT * FROM " + table;
        if (!conditions.empty())
            sql += " WHERE " + conditions;
        if (!orderBy.empty())
            sql += " ORDER BY " + orderBy;
        if (limitCount > 0)
            sql += " LIMIT " + to_string(limitCount);
        return sql;
    }
};

int main()
{
    Query q;
    string sql = q.from("users")
                  .where("age > 18")
                  .where("status = 'active'")
                  .order("name")
                  .limit(10)
                  .build();
    
    cout << sql << endl;
    // SELECT * FROM users WHERE age > 18 AND status = 'active' ORDER BY name LIMIT 10
    
    return 0;
}

---

注意事项

1. this 只能在非静态成员函数中使用

2. 不能给 this 赋值，它是一个右值

3. 静态成员函数没有 this 指针

class Example
{
public:
    static void staticFunc()
    {
        // cout << this->value;  // 错误！静态函数没有 this
    }
    
    void normalFunc()
    {
        // this = nullptr;  // 错误！不能给 this 赋值
    }
};

---

理解 this 指针，是理解 C++ 面向对象机制的重要一步。它揭示了成员函数是如何"知道"自己在操作哪个对象的。

习题

• 修改 Person 类的 setter 方法，使其支持链式调用。

• 设计一个 Calculator 类，支持链式调用进行连续的加减乘除运算。