Skip to content

Latest commit

 

History

History
393 lines (290 loc) · 9.03 KB

C++基础：深入理解C++中的this关键字.md

File metadata and controls

393 lines (290 loc) · 9.03 KB

深入理解C++中的this关键字

1. 引言

1.1 什么是this关键字？

this关键字是C++中的一个特殊指针，它指向当前对象的地址。每个非静态成员函数在被调用时，都会隐式地传递一个this指针，用于访问调用该函数的对象的成员变量和成员函数。

1.2 this关键字的作用和重要性

this关键字的主要作用是：

  • 在成员函数中访问当前对象的成员变量和成员函数。
  • 区分同名的局部变量和成员变量。
  • 在链式调用中返回当前对象。
  • 在构造函数中调用其他构造函数（委托构造）。
1.3 为什么需要this关键字？

在C++中，每个对象都有自己的成员变量，但在成员函数中，编译器需要知道当前操作的是哪个对象的成员变量。this关键字提供了一种明确的方式来访问当前对象的成员。

2. this关键字的基本概念

2.1 this关键字的定义

this是一个指向当前对象的指针，其类型为ClassName* const，其中ClassName是当前类的名称。

2.2 this关键字的类型

this指针的类型是ClassName* const，这意味着this指针本身是常量，不能被修改，但this指针所指向的对象的内容可以被修改。

2.3 this关键字的生命周期

this指针的生命周期与对象的生命周期相同。当对象被创建时，this指针被隐式传递给成员函数；当对象被销毁时，this指针也随之失效。

3. this关键字的使用场景

3.1 在成员函数中访问当前对象的成员变量
3.1.1 代码示例
#include <iostream>

class MyClass {
public:
    int value;

    void setValue(int value) {
        this->value = value;  // 使用this指针访问当前对象的成员变量
    }

    void printValue() {
        std::cout << "Value: " << this->value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.setValue(42);
    obj.printValue();
    return 0;
}
3.1.2 代码解析

在setValue函数中，this->value用于访问当前对象的value成员变量。如果不使用this，编译器会认为value是函数参数，而不是成员变量。

3.2 在成员函数中区分同名局部变量和成员变量
3.2.1 代码示例
#include <iostream>

class MyClass {
public:
    int value;

    void setValue(int value) {
        this->value = value;  // 使用this指针区分同名局部变量和成员变量
    }

    void printValue() {
        std::cout << "Value: " << this->value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.setValue(42);
    obj.printValue();
    return 0;
}
3.2.2 代码解析

在setValue函数中，参数value和成员变量value同名。使用this->value明确指定访问的是成员变量，而不是局部变量。

3.3 在链式调用中返回当前对象
3.3.1 代码示例
#include <iostream>

class MyClass {
public:
    int value;

    MyClass& setValue(int value) {
        this->value = value;
        return *this;  // 返回当前对象的引用，支持链式调用
    }

    void printValue() {
        std::cout << "Value: " << this->value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.setValue(42).setValue(100);  // 链式调用
    obj.printValue();
    return 0;
}
3.3.2 代码解析

在setValue函数中，返回*this表示返回当前对象的引用，从而支持链式调用。

3.4 在构造函数中调用其他构造函数（委托构造）
3.4.1 代码示例
#include <iostream>

class MyClass {
public:
    int value;

    MyClass(int value) : value(value) {}

    MyClass() : MyClass(0) {}  // 委托构造函数

    void printValue() {
        std::cout << "Value: " << this->value << std::endl;
    }
};

int main() {
    MyClass obj1;
    obj1.printValue();

    MyClass obj2(42);
    obj2.printValue();
    return 0;
}
3.4.2 代码解析

在无参构造函数中，使用MyClass(0)委托调用带参构造函数，避免了代码重复。

4. this关键字的隐式使用

4.1 编译器如何隐式使用this

编译器在调用非静态成员函数时，会隐式地将this指针作为第一个参数传递给函数。例如，obj.func()会被编译器转换为func(&obj)。

4.2 this关键字在编译器中的实现细节

在编译器内部，this指针通常被实现为一个隐藏的参数，传递给每个非静态成员函数。

4.3 隐式this的使用对性能的影响

隐式使用this指针对性能的影响非常小，因为现代编译器会进行优化，确保this指针的使用不会引入额外的开销。

5. this关键字的注意事项

5.1 this关键字在常量成员函数中的使用
5.1.1 代码示例
#include <iostream>

class MyClass {
public:
    int value;

    void setValue(int value) {
        this->value = value;
    }

    void printValue() const {
        std::cout << "Value: " << this->value << std::endl;
    }
};

int main() {
    const MyClass obj = {42};
    obj.printValue();
    return 0;
}
5.1.2 代码解析

在常量成员函数中，this指针的类型是const MyClass* const，表示不能修改当前对象的内容。

5.2 this关键字在静态成员函数中的限制
5.2.1 代码示例
#include <iostream>

class MyClass {
public:
    static void staticFunc() {
        // this->value;  // 错误：静态成员函数中不能使用this指针
    }
};

int main() {
    MyClass::staticFunc();
    return 0;
}
5.2.2 代码解析

静态成员函数不与任何对象关联，因此不能使用this指针。

5.3 this关键字在析构函数中的使用
5.3.1 代码示例
#include <iostream>

class MyClass {
public:
    ~MyClass() {
        std::cout << "Destructor called for object at " << this << std::endl;
    }
};

int main() {
    MyClass obj;
    return 0;
}
5.3.2 代码解析

在析构函数中，this指针用于标识当前正在销毁的对象。

5.4 this关键字的空指针问题
5.4.1 代码示例
#include <iostream>

class MyClass {
public:
    void printValue() {
        std::cout << "Object at " << this << std::endl;
    }
};

int main() {
    MyClass* obj = nullptr;
    obj->printValue();  // 虽然this是空指针，但函数中没有解引用this
    return 0;
}
5.4.2 代码解析

在某些情况下，this指针可能为空，但只要不对其解引用，程序不会崩溃。

6. this关键字的高级用法

6.1 使用this指针进行对象的自我赋值检查
6.1.1 代码示例
#include <iostream>

class MyClass {
public:
    int value;

    MyClass& operator=(const MyClass& other) {
        if (this == &other) {  // 自我赋值检查
            return *this;
        }
        this->value = other.value;
        return *this;
    }
};

int main() {
    MyClass obj1, obj2;
    obj1 = obj2;
    return 0;
}
6.1.2 代码解析

在赋值运算符中，使用this == &other检查是否为自我赋值，避免不必要的操作。

6.2 使用this指针实现对象的深拷贝
6.2.1 代码示例
#include <iostream>

class MyClass {
public:
    int* data;

    MyClass(int value) : data(new int(value)) {}

    ~MyClass() {
        delete data;
    }

    MyClass(const MyClass& other) {
        this->data = new int(*other.data);  // 深拷贝
    }
};

int main() {
    MyClass obj1(42);
    MyClass obj2 = obj1;
    return 0;
}
6.2.2 代码解析

在拷贝构造函数中，使用this->data = new int(*other.data)实现深拷贝，避免浅拷贝带来的问题。

6.3 使用this指针在多态中的应用
6.3.1 代码示例
#include <iostream>

class Base {
public:
    virtual void print() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived class" << std::endl;
    }
};

int main() {
    Base* obj = new Derived();
    obj->print();  // 多态调用
    delete obj;
    return 0;
}
6.3.2 代码解析

在多态中，this指针用于动态绑定，确保调用正确的虚函数。

7. this关键字的性能分析

7.1 this关键字对内存的影响

this指针本身占用4或8字节的内存（取决于系统架构），但对整体内存使用的影响可以忽略不计。

7.2 this关键字对函数调用性能的影响

this指针的传递对函数调用的性能影响非常小，现代编译器会进行优化。

7.3 如何优化this关键字的使用

合理使用this指针，避免不必要的解引用，可以提高代码的性能。

8. 总结

8.1 this关键字的优点和局限性

this关键字的优点包括：

  • 明确访问当前对象的成员。
  • 支持链式调用和委托构造。

局限性包括：

  • 在静态成员函数中不能使用。
  • 可能引入空指针问题。