1. Toy模板网首页
  2. > Toy博客

C++奇迹之旅：隐含的this指针

6月前 作者：阿森要自信 分类：Toy博客 阅读(35) 违法举报

这篇具有很好参考价值的文章主要介绍了C++奇迹之旅：隐含的this指针。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈

📝this指针

在C++编程中，有一个特殊的指针叫做this指针，它在类的成员函数中扮演着重要的角色。本文将从一个简单的例子开始，逐步探讨this指针的概念、作用和用法。

🌠 this指针的引出

我们先来定义一个日期类 Date

class date
{
public:
	void init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

int main()
{
	date d1;
	date d2;
	d1.init(2006, 6, 27);
	d2.init(2024, 4, 15);

	d1.print();
	d2.print();

	return 0;
}

对于上述类，有这样的一个问题：
Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函
数时，两个Date类d1和d2调用的是同一个函数，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
我们先看一个打印函数print()，里面访问的成员变量是哪里的，是private声明下的吗？

void Print()
 {
	 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
 
 private:
 	int _year;     // 年
 	int _month;    // 月
 	int _day;      // 日
};

其实不是，这里只是声明，没有分配空间，访问的是类对象d1，d2各自的成员变量

这里的 _year、_month 和 _day 并不是 Print() 函数中访问的成员变量。这些成员变量是在 private 访问说明符下声明的,但是并没有分配空间。实际上,在 Print() 函数中访问的是类对象 d1 和 d2 各自的成员变量。当我们调用 d1.Print() 和 d2.Print() 时,Print() 函数会分别访问 d1 和 d2 对象的 _year、_month 和 _day 成员变量。

这里我们是怎么知道d1和d2对象怎么特定访问到各自的成员变量呢？我们在上节第三种猜想可以知道对象的存储方式：只保存成员变量，成员函数存放在公共的代码段
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
类的成员函数代码只保存一份,存放在程序的公共代码段中。每个类对象中只保存成员变量的实际数据。对象中不保存任何指向成员函数的指针。
当通过对象调用成员函数时,编译器会根据成员函数的名称和类型,找到对应的函数代码地址,并传入对象自身的this指针,来完成函数的调用
总结来说：当成员函数print()通过this指针，访问这些成员变量时，本质上来说，是访问调用该对象（d1）下的成员函数（print())，里面的函数的访问的成员变量对应是对象（d1）的成员变量。

那类对象d1,d2是怎么找到两个函数的，this 指针是一个指向当前对象的指针。当我们调用一个类的成员函数时,编译器会自动将当前对象的地址传递给 this 指针。通过 this 指针,我们可以访问当前对象的成员变量和成员函数。这在需要区分同名的成员变量和形参时很有用。
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
经过编译器处理，他会自动加上this指针，这就是说为什么叫隐含式this，而在调用的时候编译器是这这样的：

d1.print(&d1);
	void print(date* this)
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
		//cout << d1->_year << "-" << d1->_month << "-" << d1->_day << endl;
	}
	
d2.print(&d2);
	void print(date* this)
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
		//cout << d2->_year << "-" << d2->_month << "-" << d2->_day << endl;
	}

首先会把调用的对象当做形参进行传递，这就是为什么每个类对象能够稳定的访问自己的类成员变量，这里不就同我们C语言数据传递地址使用指针访问变量嘛
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
总结来说：C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

🌉 this指针的特性

  1. this指针的类型：类型 const，即成员函数中，不能给this指针赋值*。函数的本质原型为void print(date* const this)，我们在学指针时【C语言】深入解开指针（二）知道const 后的内容能不能改变，取决于const的位置，因此这里的const限制的this指针,但this指针的内容可以修改。
    C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
  2. this指针是成员函数第一个隐含的指针，一般情况是由编译器ecx寄存器自动传递，不需要用户传递
    C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
    注意点：
  3. 实参和形参的位置不能显示写，编译器自己加，但是在类里面可以用
    无论是哪一形参或者实参的哪一个位置显示写了，编译器都会发生报错。
    C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
    C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
  4. 只能在“成员函数”的内部使用
    C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈

🌉this指针存在哪里

假设我们有一个简单的 C++ 类 MyClass，它包含一个成员变量 x 和一个成员函数 printX()。

class MyClass 
{
public:
    void setX(int value) 
    {
        x = value;
    }

    void printX() 
    {
        std::cout << "x = " << x << std::endl;
    }

private:
    int x;
};

当我们创建一个 MyClass 对象并调用 printX() 函数时,内存中的情况如下:

  1. 在堆内存区域,我们创建了一个 MyClass 对象,其中包含成员变量 x。

  2. 当我们调用 printX() 函数时,函数会在栈内存区域分配一块空间,用于存储函数的局部变量和参数。

  3. 在这个函数栈空间中,编译器会自动添加一个隐式的 this 指针参数。这个 this 指针指向当前正在执行 printX() 函数的 MyClass 对象在堆内存中的地址。

示意图如下:

C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈

在 printX() 函数内部,我们可以使用 this 指针来访问和操作当前对象的成员变量 x。例如:

void printX() 
{
    std::cout << "x = " << this->x << std::endl;
}

这里的 this->x 就是通过 this 指针访问当前对象在堆内存中的成员变量 x。

当 printX() 函数执行完毕并返回时,函数栈空间会被释放,包括 this 指针在内的所有局部变量。但是,对象在堆内存中的成员变量 x 仍然存在,直到对象被销毁。

总结：this指针实际上是存储在栈空间上的。当一个对象调用一个成员函数时，该对象的地址会被传递到栈中，并作为参数传递给成员函数。这个参数即是this指针所指向的对象的地址。因此，this指针所存储的地址也就位于栈上。

每个函数调用都会在栈上分配一段内存空间，用于存储函数的参数、局部变量和其他相关信息。在成员函数被调用时，this指针会作为一个隐含参数传递到函数的参数列表中，并在栈上存储对象的地址。通过this指针，成员函数可以在堆内存中准确地定位和访问对象的成员变量和成员函数。

🌠思考

  1. 下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{

public:
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

答案是：正常运行。
首选我们知道指针p为nullptr，意思是指向A类型的对象的指针p为空，print()只做了一件事，那就是打印，没有访问对象里的成员变量，Print() 函数只是简单地打印一个字符串,Print() 函数调用并不会尝试访问任何无效的内存地址。
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
小结：成员函数的调用如果没有依赖于this指针指向对象实例化的某个成员变量的有效内存地址时，也就是不访问该对象的成员变量的的成员函数，通过nullptr调用不会发生运行时的错误，Print() 函数只是简单地打印一个字符串。那如果我们看看底层汇编：
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈
好的,让我来解释一下这段汇编代码:

 1. `00B925E5 mov dword ptr [p], 0`
 2. 将指针 `p` 初始化为 `nullptr`(0)。它将 `p` 所指向的内存地址设置为 0。

 3. `00B925EC mov ecx, dword ptr [p]`
 4. 将 `p` 的值(也就是 0)加载到 `ecx` 寄存器中。在 x86 架构上,`ecx` 寄存器通常用作函数调用的第一个参数。

 5. `00B925EF call A::Print (0B91442h)`
 6. 调用了 `A::Print()` 函数。由于 `p` 的值为 0(即 `nullptr`),所以这实际上是通过一个空指针来调用成员函数。

可以看出，在VS汇编上，它就把指针存到寄存器中，然后call函数的地址，然后在函数内部，如果用这个指针去访问成员变量，就会发生运行崩溃。

  1. 下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{ 
public:
    void PrintA() 
   {
        cout<<_a<<endl;
   }
private:
 int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

答案是：运行崩溃
分析：如前面所说那样，this->_a，等同于空指针访问成员变量，访问内存，会发生运行时的崩溃。
C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈

🌠C语言和C++实现Stack的对比

🌉 C语言实现

typedef int DataType;
typedef struct Stack
{
    DataType* array;
    int capacity;
    int size;
}Stack;
void StackInit(Stack* ps)
{
    assert(ps);
    ps->array = (DataType*)malloc(sizeof(DataType) * 3);
    if (NULL == ps->array)
    {
        assert(0);
        return;
    }
    ps->capacity = 3;
    ps->size = 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);
    if (ps->array)
    {
        free(ps->array);
        ps->array = NULL;
        ps->capacity = 0;
        ps->size = 0;
    }
}
void CheckCapacity(Stack* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity * 2;
        DataType* temp = (DataType*)realloc(ps->array,
            newcapacity * sizeof(DataType));
        if (temp == NULL)
        {
            perror("realloc申请空间失败!!!");
            return;
        }
        ps->array = temp;
        ps->capacity = newcapacity;
    }
}
void StackPush(Stack* ps, DataType data)
{
    assert(ps);
    CheckCapacity(ps);
    ps->array[ps->size] = data;
    ps->size++;
}
int StackEmpty(Stack* ps)
{
    assert(ps);
    return 0 == ps->size;
}
void StackPop(Stack* ps)
{
    if (StackEmpty(ps))
        return;
    ps->size--;
}
DataType StackTop(Stack* ps)
{
    assert(!StackEmpty(ps));
    return ps->array[ps->size - 1]
}
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->size;
}
int main()
{
    Stack s;
    StackInit(&s);
    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackPop(&s);
    StackPop(&s);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackDestroy(&s);
    return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

  • 每个函数的第一个参数都是Stack*
  • 函数中必须要对第一个参数检测，因为该参数可能会为NULL
  • 函数中都是通过Stack*参数操作栈的
  • 调用时必须传递Stack结构体变量的地址
    结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据
    的方式是分离开的    ，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出
    错。

🌉 C++实现

class A
{
public:
    void PrintA()
    {
        cout << _a << endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}


typedef int DataType;
class Stack
{
public:
    void Init()
    {
        _array = (DataType*)malloc(sizeof(DataType) * 3);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = 3;
        _size = 0;
    }
    void Push(DataType data)
    {
        CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    void Pop()
    {
        if (Empty())
            return;
        _size--;
    }
    DataType Top() { return _array[_size - 1]; }
    int Empty() { return 0 == _size; }
    int Size() { return _size; }
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            int newcapacity = _capacity * 2;
            DataType* temp = (DataType*)realloc(_array, newcapacity *
                sizeof(DataType));
            if (temp == NULL)
            {
                perror("realloc申请空间失败!!!");
                return;
            }
            _array = temp;
            _capacity = newcapacity;
        }
    }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);

    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Pop();
    s.Pop();
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Destroy();
    return 0;
}

C++中通过类可以将数据 以及 操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack * 参数是编译器维护的，C语言中需用用户自己维护。

🚩总结

C++奇迹之旅：隐含的this指针,【C++的奇迹之旅】,c++,开发语言,c语言,this指针,C++栈文章来源地址https://www.toymoban.com/news/detail-860933.html

到了这里，关于C++奇迹之旅：隐含的this指针的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • C++奇迹之旅：深入理解赋值运算符重载

    C++奇迹之旅：深入理解赋值运算符重载

    运算符重载是C++中的一个重要特性，他允许我们为自定义的类型定义自己的运算符行为。通过运算符重载， 我们可以使用与内置数据类型相同的语法来操作自定义类型，从而提高代码的可读性和可维护性 。 还是我们熟悉的日期函数： 然后我们定义两个日期对象d1和d2: 当你想

    2024年04月26日
    浏览(37)
  • C++奇迹之旅：探索类对象模型内存的存储猜想

    C++奇迹之旅：探索类对象模型内存的存储猜想

    上回我们学习了类的定义，初步了解了什么是类？类的定义，以及类的三个访问限定符： public ， private ， protected ，本小节将讲解类的实例化，类对象模型的猜想存储，及三种简单类的计算。 在 C++ 中,类的实例化是指创建一个类的对象。当我们定义了一个类之后,就可以根据

    2024年04月12日
    浏览(36)
  • C++奇迹之旅：从0开始实现日期时间计算器

    C++奇迹之旅：从0开始实现日期时间计算器

    通过前面学完了 C++ 的默认成员函数，实践出真知，本小节我们将一起来实现一个简单上手的日期时间计算器，阿森和你一起一步一步的操作实现！ 完整代码在文章末尾哦 为了代码的维护性和可观型，我们在设置三个文件头文件 Date.h ，源文件 Date.cpp ， Test.cpp 我们先把头文

    2024年04月28日
    浏览(34)
  • 我的C++奇迹之旅：值和引用的本质效率与性能比较

    我的C++奇迹之旅：值和引用的本质效率与性能比较

    引用 不是新定义一个变量，而是给 已存在变量取了一个别名 ，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。 定义： 类型引用变量名(对象名) = 引用实体； 例如以下代码，在变量名前加一个 ，意思是一个引用类型， b 是 a 的别名，也就是

    2024年04月27日
    浏览(54)
  • c++类开发的第三篇（讲明白友元函数和this指针）

    c++类开发的第三篇（讲明白友元函数和this指针）

    c++实现了 封装 ， 数据 和 处理数据的操作(函数) 是分开存储的。 c++中的 非静态数据成员 直接内含在类对象中，就像c语言的struct一样。 成员函数并不会出现在对象中，而是作为类的一部分存储在代码段中，需要通过对象或对象指针进行调用。成员函数可以访问类的所有成员

    2024年02月21日
    浏览(45)
  • 【C++的奇迹之旅（二）】C++关键字&&命名空间使用的三种方式&&C++输入&输出&&命名空间std的使用惯例

    【C++的奇迹之旅（二）】C++关键字&&命名空间使用的三种方式&&C++输入&输出&&命名空间std的使用惯例

    C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式 等。熟悉C语言之后，对C++学习有一定的帮助，本章节主要目标： 补充C语言语法的不足，以及C++是如何对C语言设计不合理的地方进行优化的，比如：作用 域方面、IO方面、函数方面、

    2024年04月09日
    浏览(87)
  • C++学习之旅 - 指针

    C++学习之旅 - 指针

    指针的基本概念 指针的作用: 可以通过指针间接访问内存 内存编号是从0开始记录的，一般用十六进制数字表示 可以利用指针变量保存地址 指针的定义与使用 指针的语法 数据类型* 指针变量名 指针占用的内存空间 我这里是8个字节的原因是我是64位电脑 你可以在 VSstudio 中更

    2024年02月08日
    浏览(39)
  • 【C/C++】C语言开发者必读：迈向C++的高效编程之旅

    【C/C++】C语言开发者必读：迈向C++的高效编程之旅

    🧑 作者简介 ：阿里巴巴嵌入式技术专家，深耕嵌入式+人工智能领域，具备多年的嵌入式硬件产品研发管理经验。 📒 博客介绍 ：分享嵌入式开发领域的相关知识、经验、思考和感悟，欢迎关注。提供嵌入式方向的学习指导、简历面试辅导、技术架构设计优化、开发外包等

    2024年03月20日
    浏览(48)
  • c++ this指针

    c++ this指针

    this指针介绍： c++中成员变量和成员函数分开存储，每一个非静态成员函数只会有一个实例，多个同类型对象共用这一个成员函数。那么代码怎么区分哪个对象调用自己呢？this指针由此应运而生。 c++通过提供对象指针，this指针。 this指针指向被调用的成员函数所属的对象 ,当

    2024年02月03日
    浏览(37)
  • C++“this”指针的使用

    C++“this”指针的使用

    1.this指针的引出 先看一段代码： Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置Day1对象，而不是设置Day2对象呢？ C++中通过引入this指针解决该问题， 即：C++编译器给每个“非静态的成员函数“增

    2024年02月05日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包