跳到主要内容

C++ this指针

什么是this指针​

在面向对象编程中，当我们创建一个类的对象时，每个对象都有自己的成员变量和成员函数。但实际上，成员函数只存储一份，被所有对象共享。那么问题来了：同一个成员函数如何知道它当前是在操作哪个对象呢？

这就是this指针的作用。this指针是一个隐含于每个非静态成员函数中的特殊指针，它指向调用该成员函数的对象。也就是说，当一个对象调用成员函数时，编译器会自动将对象的地址传递给this指针。

重要概念

this指针是一个隐式参数，不需要定义，直接使用即可。它指向当前对象，即调用成员函数的对象。

this指针的特性​

  1. this指针是一个常量指针，你不能修改它的指向
  2. this指针只能在类的非静态成员函数内使用
  3. this指针不需要定义，编译器自动提供
  4. 静态成员函数没有this指针，因为静态成员函数不属于某个对象

this指针的基本用法​

1. 区分成员变量和参数​

当成员函数的参数与成员变量同名时，可以使用this指针来明确地引用成员变量：

cpp
class Person {
private:
    string name;
    int age;

public:
    // 构造函数参数与成员变量同名
    Person(string name, int age) {
        // 使用this指针区分成员变量和参数
        this->name = name;
        this->age = age;
    }
    
    void displayInfo() {
        cout << "姓名: " << name << ", 年龄: " << age << endl;
    }
};

// 使用示例
int main() {
    Person person("张三", 25);
    person.displayInfo();
    return 0;
}

输出结果：

姓名: 张三, 年龄: 25

2. 返回对象自身的引用​

在链式编程模式中，返回对象自身的引用非常有用，可以使多个操作连续进行：

cpp
class Counter {
private:
    int count;

public:
    Counter() : count(0) {}
    
    // 返回对象自身的引用，实现链式调用
    Counter& increment() {
        count++;
        return *this;  // 返回当前对象的引用
    }
    
    Counter& add(int value) {
        count += value;
        return *this;  // 返回当前对象的引用
    }
    
    void display() {
        cout << "当前计数: " << count << endl;
    }
};

// 使用示例
int main() {
    Counter counter;
    // 链式调用
    counter.increment().add(5).increment().display();
    return 0;
}

输出结果：

当前计数: 7

this指针的高级应用​

在构造函数中调用另一个构造函数（C++11）​

在C++11中，我们可以使用this指针以及委托构造函数的特性，在一个构造函数中调用另一个构造函数：

cpp
class Rectangle {
private:
    double length;
    double width;

public:
    // 主构造函数
    Rectangle(double length, double width) {
        this->length = length;
        this->width = width;
    }
    
    // 委托构造函数 - 创建正方形
    Rectangle(double side) : Rectangle(side, side) {
        // 委托给主构造函数后，可以执行额外操作
        cout << "创建了一个正方形!" << endl;
    }
    
    double getArea() {
        return length * width;
    }
};

// 使用示例
int main() {
    Rectangle rect(5.0, 3.0);
    cout << "矩形面积: " << rect.getArea() << endl;
    
    Rectangle square(4.0);
    cout << "正方形面积: " << square.getArea() << endl;
    
    return 0;
}

输出结果：

矩形面积: 15
创建了一个正方形!
正方形面积: 16

判断两个对象是否为同一个对象​

this指针可以用来比较两个对象是否是同一个对象：

cpp
class Test {
public:
    bool isSameObject(const Test& other) {
        // 比较地址是否相同
        if (this == &other) {
            return true;
        }
        return false;
    }
};

// 使用示例
int main() {
    Test obj1;
    Test obj2;
    
    if (obj1.isSameObject(obj1)) {
        cout << "obj1和obj1是同一个对象" << endl;
    } else {
        cout << "obj1和obj1不是同一个对象" << endl;
    }
    
    if (obj1.isSameObject(obj2)) {
        cout << "obj1和obj2是同一个对象" << endl;
    } else {
        cout << "obj1和obj2不是同一个对象" << endl;
    }
    
    return 0;
}

输出结果：

obj1和obj1是同一个对象
obj1和obj2不是同一个对象

this指针与const成员函数​

在const成员函数中，this指针的类型是const Class* const，这意味着你不能修改对象的成员变量：

cpp
class ConstExample {
private:
    int value;

public:
    ConstExample(int v) : value(v) {}
    
    // 非const成员函数，this指针类型为 ConstExample* const
    void setValue(int v) {
        value = v;  // 可以修改成员变量
    }
    
    // const成员函数，this指针类型为 const ConstExample* const
    void display() const {
        // value = 100;  // 错误！不能在const成员函数中修改成员变量
        cout << "值: " << value << endl;
    }
    
    // const成员函数中修改mutable成员变量是允许的
    mutable int accessCount;
    
    void access() const {
        accessCount++;  // 在const成员函数中修改mutable成员变量是合法的
        cout << "访问次数: " << accessCount << endl;
    }
};

实际应用场景​

场景一：实现流式接口（Fluent Interface）​

流式接口是一种面向对象的API设计风格，其目的是通过方法链提高代码的可读性。许多现代库如jQuery、Boost和STL中的一些组件都使用了这种模式：

cpp
class StringBuilder {
private:
    string data;

public:
    StringBuilder() : data("") {}
    
    StringBuilder& append(const string& text) {
        data += text;
        return *this;
    }
    
    StringBuilder& appendLine(const string& text) {
        data += text + "\n";
        return *this;
    }
    
    string toString() const {
        return data;
    }
};

// 使用示例
int main() {
    StringBuilder builder;
    string result = builder.append("你好，")
                          .append("世界！")
                          .appendLine("")
                          .append("C++编程很有趣！")
                          .toString();
    
    cout << result << endl;
    return 0;
}

输出结果：

你好，世界！
C++编程很有趣！

场景二：避免对象自赋值​

在重载赋值运算符时，通常需要检查自赋值情况，以避免不必要的操作和潜在的错误：

cpp
class DynamicArray {
private:
    int* data;
    int size;

public:
    DynamicArray(int size) : size(size) {
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = 0;
        }
    }
    
    ~DynamicArray() {
        delete[] data;
    }
    
    // 赋值运算符重载
    DynamicArray& operator=(const DynamicArray& other) {
        // 检查自赋值
        if (this == &other) {
            return *this;  // 避免自赋值
        }
        
        // 释放原有资源
        delete[] data;
        
        // 分配新资源
        size = other.size;
        data = new int[size];
        
        // 复制数据
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }
        
        return *this;
    }
    
    void setData(int index, int value) {
        if (index >= 0 && index < size) {
            data[index] = value;
        }
    }
    
    void display() {
        for (int i = 0; i < size; i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }
};

总结​

this指针是C++面向对象编程中的一个核心概念，它使我们能够：

  1. 在成员函数内部引用当前对象
  2. 区分同名的成员变量和参数
  3. 实现链式调用
  4. 检测对象自赋值
  5. 在构造函数中调用其他构造函数（C++11）

理解this指针的工作原理对于掌握C++的面向对象特性至关重要。随着你逐渐深入学习C++，你会发现this指针在许多高级设计模式和技术中都扮演着重要角色。

使用建议

避免在静态成员函数中使用this指针，因为静态成员函数不属于特定对象。当返回*this时，最好返回引用而不是值，以避免不必要的对象复制。

练习题​

  1. 创建一个Calculator类，实现加、减、乘、除四种基本算术操作，并使用链式调用的方式使其可以连续计算。
  2. 创建一个具有自引用能力的链表节点类Node，可以添加下一个节点并返回自身引用。
  3. 实现一个Person类，包含姓名和年龄属性，并重载赋值运算符，确保处理自赋值的情况。