【c++】析构函数的疑思

#include 
using namespace std;

class Point {
private:
	int x;
	int y;
public:

	//定义默认构造函数方式二：在已有构造函数的所有参数提供默认值
	//Point(int a = 0, int b = 0) {
	Point(int a, int b) {
		x = a;
		y = b;
		cout << "create: " << this << " " << x << "," << y << endl;
	}

	//定义默认构造函数方式一：为类定义构造函数后，程序员需要自己提供默认构造函数，通过函数重载来定义一个无参构造函数
	Point() {
		x = 0;
		y = 0;
		cout << "create: " << this << " " << x << "," << y << endl;
	}

	Point operator+(const Point& p)const {
		cout << this << " operator+ " << &p << endl;
		【写法一】产生析构两次
		//Point result; //构造临时变量，值是0,0
		//cout << "result: " << &result << endl;
		//result = Point(this->x + p.x, this->y + p.y); //构造临时变量，值是加法后的值
		//return result;

		【写法二】产生一个析构
		//Point result = Point(this->x + p.x, this->y + p.y);//创建临时变量，析构临时变量
		//cout << "result: " << &result << endl;
		//return result;

		//【写法三】产生一次析构
		return Point(this->x + p.x, this->y + p.y);


	}

	void operator=(const Point& p) {
		//【问题3】这里为什么还会产生了一个临时变量？特意使用常量引用的。
		cout << this << " operator= " << &p << endl;
		this->x = p.x;
		this->y = p.y;
	}

	void show() {
		cout << this << " " << x << "," << y << endl;
	}

	~Point() {
		cout << this << " 析构" << x << "," << y << endl;
	}
};


int main()
{
    Point p(1, 1);
	Point t(2, 2);
	t = p + t;
	t.show();
	cout << "-----------------" << endl;
}

【写法三的输出】
create: 00EFFB5C 1,1 //创建变量p
create: 00EFFB4C 2,2 //创建变量t
00EFFB5C operator+ 00EFFB4C //执行加法t=p+t
create: 00EFFA7C 3,3 //创建临时变量，值是加法后的结果
00EFFB4C operator= 00EFFA7C//临时变量的值赋值给t
00EFFA7C 析构3,3	 //析构临时变量
00EFFB4C 3,3         //输出t的值
-----------------
00EFFB4C 析构3,3     //自动变量存储在栈中，后创建的对象先析构，因此先析构t
00EFFB5C 析构1,1	 //最后析构p

与写法三的区别是

多了一个非我创建的临时变量，及其析构。

【写法二】
create: 006FF878 1,1 //创建变量p
create: 006FF868 2,2 //创建变量t
006FF878 operator+ 006FF868 //执行加法t=p+t
create: 006FF738 3,3 //创建临时变量，值是加法后的结果
result: 006FF738	//输出临时变量的
006FF738 析构3,3	//析构临时变量
006FF868 operator= 006FF798 //一个非我创建的临时变量？？被赋值给t
006FF798 析构3,3 	//析构非我创建的临时变量
006FF868 3,3		//输出t的值
-----------------
006FF868 析构3,3	//自动变量存储在栈中，后创建的对象先析构，因此先析构t
006FF878 析构1,1	//最后析构p

与写法二的区别是

由于声明result对象，因此多了result的构造和析构

【写法一】
create: 012FFBCC 1,1 //创建变量p
create: 012FFBBC 2,2 //创建变量t
012FFBCC operator+ 012FFBBC //执行加法t=p+t
create: 012FFA8C 0,0 //创建变量result
result: 012FFA8C     //输出result结果
create: 012FF9BC 3,3 //创建临时变量，值是加法后的结果
012FFA8C operator= 012FF9BC //临时变量的值赋值给result
012FF9BC 析构3,3     //析构临时变量
012FFA8C 析构3,3	 //析构变量result
012FFBBC operator= 012FFAEC //一个非我创建的临时变量？？被赋值给t
012FFAEC 析构3,3	//析构非我创建的临时变量
012FFBBC 3,3		//输出t的值
-----------------
012FFBBC 析构3,3	//自动变量存储在栈中，后创建的对象先析构，因此先析构t
012FFBCC 析构1,1	//最后析构p

写法一和写法二均存在一个非我创建的临时变量？这个临时变量能否去掉，为什么写法三却不存在，是与编译器优化之类的有关吗？需要查阅哪方面的资料？如果要深入了解的话，是需要查看代码对应的汇编语言？

先码住，等我搞懂了再回来填坑。

抱歉浪费大家几分钟看我陈述疑惑，希望有缘人不惜吝教，指点迷津，在评论区一起讨论下。