测试环境:win10+vs2013 初始代码:
#include <iostream>
using namespace std;
class Test {
private:
int ma;
public:
Test(int data = 10) :ma(data) {
cout << "Test(int)" << endl;
}
Test(const Test& t) :ma(t.ma) {
cout << "Test(const Test&)" << endl;
}
~Test() {
cout << "~Test()" << endl;
}
Test& operator=(const Test& t) {
ma = t.ma;
cout << "operator=" << endl;
return *this;
}
int getData() {
return ma;
}
};
Test getObject(Test t) {
int val = t.getData();
Test res(val);
return res;
}
int main() {
Test t1(10);
Test t2;
t2 = getObject(t1);
return 0;
}
执行结果: 上面短短的三行代码,背后居然11次的函数调用,效率太低了!!!
一、函数参数要求传入对象时,使用引用传递
#include <iostream>
using namespace std;
class Test {
private:
int ma;
public:
Test(int data = 10) :ma(data) {
cout << "Test(int)" << endl;
}
Test(const Test& t) :ma(t.ma) {
cout << "Test(const Test&)" << endl;
}
~Test() {
cout << "~Test()" << endl;
}
Test& operator=(const Test& t) {
ma = t.ma;
cout << "operator=" << endl;
return *this;
}
int getData() {
return ma;
}
};
// 相对上边的代码 仅仅是将形式参数 Test t改为Test &t
Test getObject(Test& t) {
int val = t.getData();
Test res(val);
return res;
}
int main() {
Test t1(10);
Test t2;
t2 = getObject(t1);
return 0;
}
执行结果:
可以看到,经过函数参数的优化(值传递->引用传递),减少了一次临时对象构造和析构的函数开销。 相对于之前,只有9次的函数调用,减少了两次!!!
二、函数返回时,返回临时对象,不要先定义对象,然后再返回。直接提前计算好构造该函数返回对象所需要的参数,直接返回临时对象。
#include <iostream>
using namespace std;
class Test {
private:
int ma;
public:
Test(int data = 10) :ma(data) {
cout << "Test(int)" << endl;
}
Test(const Test& t) :ma(t.ma) {
cout << "Test(const Test&)" << endl;
}
~Test() {
cout << "~Test()" << endl;
}
Test& operator=(const Test& t) {
ma = t.ma;
cout << "operator=" << endl;
return *this;
}
int getData() {
return ma;
}
};
Test getObject(Test &t) {
int val = t.getData();
// Test res(val);
// return res;
return Test(val);
}
int main() {
Test t1(10);
Test t2;
t2 = getObject(t1);
return 0;
}
执行结果:
相对于上一步优化,又减少了两次函数调用的开销!!!
三、当需要接受一个函数的返回值时,并且该返回值是一个对象,不要以赋值的方式接受,以初始化的方式接受。
#include <iostream>
using namespace std;
class Test {
private:
int ma;
public:
Test(int data = 10) :ma(data) {
cout << "Test(int)" << endl;
}
Test(const Test& t) :ma(t.ma) {
cout << "Test(const Test&)" << endl;
}
~Test() {
cout << "~Test()" << endl;
}
Test& operator=(const Test& t) {
ma = t.ma;
cout << "operator=" << endl;
return *this;
}
int getData() {
return ma;
}
};
Test getObject(Test &t) {
int val = t.getData();
// Test res(val);
// return res;
return Test(val);
}
int main() {
Test t1(10);
Test t2 = getObject(t1);// 初始化的方式接受
// t2 = getObject(t1); // 赋值的方式接受
return 0;
}
执行结果:
相对于初始的代码,同样是获取一个对象的功能,优化到现在只有两次的构造和两次析构的调用,程序减少了相当大的一部分的函数调用开销,程序的效率也得到了很大的提升。一次调用getObejct()函数可以减少7次的函数调用开销,那么100万次的调用,就能减少700万次的开销。量变产生质变!!! 对象优化的三条规则 1.当函数的形式参数需要传递对象时,不要用值接受,用引用接受。减少一次临时对象的构造和析构。 2.当函数的返回值为对象时,不要再函数题先定义好零时对象,然后再返回值。直接提前计算好构造该返回对象需要的参数,直接返回一个临时对象。 3.当接受函数返回值为对象的函数的返回值时,以初始化的方式接受,不要以赋值的方式接受。 tips:当以临时对象拷贝构造一个新对象时,编译器不会产生这个临时对象,直接以构造临时对象的方式直接构造新对象,减少一次临时对象的构造和析构。