[C++]关键字---＞this指针

逸个散人

于 2024-07-31 17:41:15 发布

阅读量716

点赞数 26

文章标签： c++ jvm 开发语言

本文链接：https://blog.csdn.net/To_be_a_master/article/details/140803175

版权

一、引出this指针

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//void Print(Date*const this)
	void Print()
	{
		//cout <<this->_year << "   " << this->_month << "   " << this->_day << endl;
		cout << _year << "   " << _month << "   " << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date D1, D2;

	D1.Init(2024, 7, 30);
	D2.Init(2024, 7, 31);


	//D1.Print(&d1)
	D1.Print();

	//D2.Print(&d2)
	D2.Print();
	return 0;
}
对于上述类，有这样的一个问题：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

二、介绍this指针

A.this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

B.小结问题：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
#include<iostream>
using namespace std;

class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}

private:
	int _a;
};



int main()
{

	A*p=nullptr;
	p->Print();

	return 0;
}

C、正常运行，p指针为空,this指针不在对象中，不需要在p指针的空间中找，直接传空指针this，打印Print()

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
#include<iostream>
using namespace std;

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};


int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

B、运行崩溃，访问的是this->_a，在this指针中查找，发现this指针为空，程序崩溃

this指针存在C++程序编译后的内存哪呢：

this指针一般情况下存在于栈中，因为this指针在成员函数作为形参，有时也存在于寄存器（ecx）中(可通过汇编查看)，不压栈，便于快速访问，具体看情况和编译器。

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

1. C语言实现

typedef int DateType;

typedef struct Stack
{
	DateType* arry;
	int capacity;
	int size;

}Stack;

//初始化
void StackInit(Stack *ps)
{
	assert(ps);
	ps->arry = (DateType*)malloc(sizeof(DateType) * 3);
	if (ps->arry==NULL)
	{
		assert(0);
		return;
	}

	ps->capacity = 3;
	ps->size = 0;
}


//销毁
void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->arry)
	{
		free(ps->arry);
		ps->arry = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}

//判满和扩容
void CheckCapacity(Stack* ps)
{
	if (ps->size==ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		DateType* temp = (DateType*)realloc(ps->arry, newcapacity * sizeof(DateType));
		if (temp==NULL)
		{
			perror("realloc 申请空间失败！");
			return;
		}
		ps->arry = temp;
		ps->capacity = newcapacity;
	}
}


//插入
void StackPush(Stack* ps, DateType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->arry[ps->size] = data;
	ps->size++;
}


//判空
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->size == 0;
}

//删除
void StackPop(Stack* ps)
{
	if (StackEmpty(ps))
	{
		return;
	}
	ps->size--;
}


//取栈顶
DateType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->arry[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相关操作函数有以下共性：

a.每个函数的第一个参数都是Stack*

b.函数中必须要对第一个参数检测，因为该参数可能会为NULL

c.函数中都是通过Stack*参数操作的

d.调用时必须传递Stack结构体变量的地址。

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

2. C++实现

typedef int DataType;

class Stack
{
public:
	void Init()
	{
		_arry =(DataType*)malloc(sizeof(DataType) * 3);
		if (_arry==NULL)
		{
			perror("malloc申请空间失败！");
			return;
		}

		_capacity = 3;
		_size = 0;
	}
	
	void Push(DataType data)
	{
		CheckCapacity();
		_arry[_size] = data;
		_size++;
	}

	void Pop()
	{
		if (Empty())
		{
			return;
		}
		_size--;
	}

	DataType Top()
	{
		return _arry[_size - 1];
	}

	int Empty()
	{
		return _size == 0;
	}

	int Size()
	{
		return _size;
	}

	void Destroy()
	{
		if (_arry)
		{
			free(_arry);
			_arry = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size==_capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_arry, newcapacity * sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc 扩容失败！");
				return;
			}

			_arry = temp;
			_capacity = newcapacity;
		}
		
	}
private:
	DataType* _arry;
	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++程序在编译后的内存分布情况如下：

栈区（Stack）：

存放局部变量、函数参数、函数调用信息等。
数据的分配和回收都由系统自动管理。
具有自动释放内存的特性，随着函数的结束而自动销毁。

堆区（Heap）：

存放动态分配的内存，由程序员手动分配和释放。
用于存放程序运行中动态创建的对象或数组。
需要手动释放内存，避免内存泄漏。

全局/静态存储区（Data/BSS）：

存放全局变量、静态变量及静态常量。
在程序运行期间一直存在，直到程序结束才被释放。
初始化的全局/静态变量存放在Data区，未初始化的全局/静态变量存放在BSS区。

代码区（Text）：

存放程序的可执行代码，包括函数体和常量数据。
只读区域，不允许修改。
可以多个进程共享同一段代码区。