C++基本函数的调用优化(构造、拷贝构造、赋值)

合理的函数可提升时间和空间的利用率

//Test1.h
#include<iostream>
using namespace std;
struct ST
{
private:
	int a;
	short b;
public:
	ST(int a=0, short b=0):a(a),b(b)
	{
		this->a = a;
		this->b = b;
		cout<<"Object was Built. "<<this<<endl;
	}
	~ST()
	{
		cout<<"Object was Free. "<<this<<endl;
	}
	ST(const ST &t);
	ST& operator=(const ST &t);
	int Get_a();
};
ST::ST(const ST &t)
{
	this->a = t.a;
	this->b = t.b;
	cout<<"Object was Copy. "<<this<<endl;
}
ST& ST::operator=(const ST &t)
{
	cout<<"Assign:"<<this<<" = "<<&t<<endl;
	if(this != &t)
	{
		this->a = t.a;
		this->b = t.b;
	}
	return *this;
}
int ST::Get_a()
{
	return this->a;
}

 

#include<iostream>
#include"Test1.h"
using namespace std;ST fun(ST t){	int value = t.Get_a();	ST tmp(value);	return tmp;}
void main()
{
	ST t(12,13);
	ST t1(t);
	ST t2;
	t2 = fun(t);
}

运行结果及分析①

1:对象t的构造和析构

2:对象t1的拷贝构造与析构

3:t2的构造与析构

ST fun(ST t)
{
	int value = t.Get_a();
	ST tmp(value);
	return tmp;
}

4:fun()函数的参数为对象,调用拷贝构造函数创建临时对象,其在fun函数结束后被析构掉

5:fun()函数内使用ST实例化类tmp,其在函数结束后被析构掉

6:函数返回时调用拷贝构造函数创建一个临时对象,该对象在完成赋值后才被析构掉,所以6并不是tmp,这个临时对象可以生存到函数结束

运行结果及分析②

ST fun(ST t)
{
	int value = t.Get_a();
	return ST (value);
}

改变的代码仅有fun()函数变化

1,2,3,4与相同,不再赘述

这里的改变是不再创造有名对象,而是直接返回一个无名临时对象,将①的5,6合二为一,所以返回时仅需要使用构造函数构造一个无名临时对象,

在赋值后被析构掉。省掉了①中的拷贝构造。

运行结果及分析③

ST fun(ST &t)
{
	int value = t.Get_a();
	return ST(value);
}

与②相比,只改变了参数

1,2,3同上

当使用引用传递参数时,就不需要使用拷贝构造函数创建临时对象,将②的4省掉,③的4与②的4作用相同

运行结果及分析④

ST fun(ST &t){	int value = t.Get_a();	return ST(value);}void main()
{
	ST t(12,13);
	ST t1(t);
	ST t2 = fun(t);
}

这里与③的不同是将主函数修改

主函数内st2从先使用构造函数初始化,再赋值,变成了直接使用赋值为其初始化

在前面我们知道

ST t(1,2);

ST st;

st = t;

ST t(1,2);

ST st = t;

实例化st 的不同是  前者先构造再拷贝构造,后者只需要拷贝构造。

所以,主函数使用了上例子后者的写法,可以直接省去t2的构造,直接拷贝构造,但是关键问题就在这里,

由于fun()函数返回的对象是一个无名的临时对象,所以编译器直接让其初始化t2,而省去拷贝构造的过程。

 总结

  1.从②我们可以知道,函数使用无名临时对象作为返回值,比在函数内创建有名临时对象更快,更节省空间,提升效率。

     2.从③我们可以看出来在函数参数为对象时,使用引用可以省掉拷贝构造。

     3.从④可以知道,在使用对象对对象进行赋值时,直接使用拷贝构造时最快的方法。这同时也说明了,无名的临时对象有时候可以被当作中间变量,而不需要从头进行拷贝构造工作。

原文地址:https://www.cnblogs.com/area-h-p/p/10326201.html

时间: 2024-11-08 19:26:25

C++基本函数的调用优化(构造、拷贝构造、赋值)的相关文章

数据结构之二叉树 (构造 拷贝构造 以及前序中序后续三种遍历方法)

首先二叉树的节点定义如下: struct BinaryNode {                  BinaryNode *_left;                  BinaryNode *_right;                  T _data;                 BinaryNode( T data ) :_data(data), _left( NULL), _right(NULL )                 {}; }; 二叉树的结构以及接口如下 te

拷贝构造,深度拷贝,关于delete和default相关的操作,explicit,类赋初值,构造函数和析构函数,成员函数和内联函数,关于内存存储,默认参数,静态函数和普通函数,const函数,友元

 1.拷贝构造 //拷贝构造的规则,有两种方式实现初始化. //1.一个是通过在后面:a(x),b(y)的方式实现初始化. //2.第二种初始化的方式是直接在构造方法里面实现初始化. 案例如下: #include<iostream> //如果声明已经定义,边不会生成 class classA { private: int a; int b; public: //拷贝构造的规则,有两种方式实现初始化 //1.一个是通过在后面:a(x),b(y)的方式实现初始化 //2.第二种初始化的方式是直

c++拷贝构造和编译优化

#include <iostream> using namespace std; class MyClass { public: MyClass(); MyClass(int i); MyClass(const MyClass &c); ~MyClass(); //后面main中测试发现func1 和func2之后没有调用拷贝构造,应该是被优化了 MyClass func1(int i){ cout<<"func1"<<endl; retur

【C/C++学院】0819-/类的成员函数与const-mutable /构造与析构/拷贝构造deletedefault以及深浅拷贝/静态成员函数成员变量类在内存的存储默认参数/友元类以及友元函数

类的成员函数与const-mutable 成员函数 Fushu.h #pragma once #include <iostream> class fushu { public: int x; int y; public: fushu(); ~fushu(); void show(); inline void showall(int x, int y);//显式内联 void setxy(int x, int y);//编译器优化,默认隐式内联 void show(int x, int y);

引用 拷贝构造 赋值语句

1.引用 C++中有一种新的数据类型,对已开辟空间在取一个名字: 就是别名,不开辟新的空间,没有空引用: 例:int &b; 错误, 交换两个数字用引用实现: 常见的几种引用形式: (1).对变量引用:int a = 10; int &b = a; (2).对指针引用:int *p = &a; int *&q = p; (3).对数组引用:int ar[3] = {1, 2, 3,}; int (&b)[3] = ar; 此外还有以下类型的引用: (1).常引用 c

【C++系列经典例子】C++默认构造,拷贝,赋值,析构四函数

本例子来自于学习视频,不是原创. 首先,我们已经知道我们创建类时会有四个默认函数(实际是有6个,具体以后再探究) 分别是:(以test类为例子) class test { private: int value; } 1.构造函数: test(int x=0) 2.拷贝构造函数: test(const test& it) 3.赋值函数 test &operator(const test& it) 4.析构函数 ~test() 以下是具体应用四个函数的过程的一个经典例子,能让我们更好的

C++ 拷贝构造

在C++存在拷贝构造函数,拷贝构造函数与不同构造函数形成重载(这一点很重要),这就意味着(要么class入口为普通构造函数,要么为拷贝构造函数,不可能2个都会执行的).好了 , 下面可是今天的Studying 一 , 实际上C++类中有一个默认的拷贝构造,它的作用是将此类中非static成员逐一copy.现在先不管默认的Copy构造,我先先重载一下Copy构造: #include <iostream> using namespace std; class copyC { public:    

赋值函数与拷贝构造的差异

C++ 拷贝构造函数 赋值构造函数 ================================= 一句话,赋值函数的前提是对象已定义:而拷贝构造是执行时才会创建一个对象.拷贝构造需要的是深拷贝. 赋值函数一般模式: type& operator =(const type& par) { // (1) 检查自赋值 if( this == &par ) return *this; // (2) 释放原有的内存资源 //(3)分配新的内存资源,并复制内容 ,2.3顺序没讲究,注意释

拷贝构造,操作符重载

 拷贝构造 #include <iostream> #include <string.h> using namespace std; class mystring { public: char *s; public: mystring() { s = new char[1024]; cout << "mystring" << endl; } //拷贝构造 mystring(const mystring &it) { s= ne