这篇文章主要介绍了C++ 类this及返回自身对象的引用方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教 +
目录
this及返回自身对象的引用
this:调用成员函数的时候，编译器负责把对象地址传（&myTime）递给成员函数中隐藏的this形参。
在系统角度来看，任何对类成员的直接访问都是被this隐式调用的。
- this有个const修饰符，只能用来指向已确定的那个对象，不能更改。
- this只能在成员函数中使用，全局函数静态函数不能使用this。
- 在成员普通函数中，this是一个指向非const对象的const指针。（this 等价于 Time *const this,const修饰this，this不能指向其他对象，但this指向的对象中的成变量可以被修改。）
- 在const成员函数中，this指针是一个指向const对象的const指针（this 等价于 const Time * const this）。
| 1 2 3 4 5 6 7 8 9 |
class Time {
public:
int hour;
int minute;
public:
//把对象自己返回去了
Time& add_hour(int temp_hour);
Time& add_minute(int minute);
};
|
| 1 2 3 4 5 6 7 8 9 |
//实际工作中，this能省则省。
Time& Time::add_hour(int temphour) {
this->hour += temphour;//等价于 hour += temphour;
return *this;//把对象自己返回去了，固定写法。指向本对象的指针。*this表示对象本身。
}
Time& Time::add_minute(int minute) {
this->minute += minute;//区分成员变量和形参
return *this;
}
|
| 1 2 3 |
Time myTime;
myTime.add_hour(3);
myTime.add_hour(3).add_minute(10);//返回自己，可以连续调用。
|
c++如何返回对象
返回对象，无非两种方式，返回栈对象和堆对象指针，栈对象指针不能返回，因为可能使用不该使用的内存，堆对象也不能直接返回，因为会产生内存泄漏。下面，我们分析两种返回方式的优缺点，及针对缺点的解决方案。
这里有个注意点，返回this指针指向的自身对象时，可以返回引用。
返回栈对象
- 优点：不用手动释放内存，避免了内存泄漏；
- 缺点：会产生对象拷贝，如果对象比较大，比如，对象里面有大数组，会产生性能开销。
返回堆对象指针
- 优点：不会产生对象拷贝，对性能友好；
- 缺点：函数调用之后手动释放对象，代码管理难度和内存泄漏风险提高。
那有没有办法，把上面的缺点全克服了呢？有！
- 返回栈对象：用移动构造函数减少大对象拷贝；
- 返回堆指针：借助智能指针，避免内存泄漏。
注意：返回栈对象时，虽然很多编译器做了编译优化，即使不写移动构造函数，也不会产生对象拷贝，但是，为了应对还没有编译优化的编译器，建议写好移动构造函数。
可以看下面代码。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
#include <iostream>
using namespace std;
class A{
public:
int i;
string* bigObj; //假设这是大对象
A(){
bigObj=new string("abc");
cout<<"A created."<<endl;
}
~A(){
if(bigObj!=nullptr){
delete bigObj;
bigObj=nullptr;
}
cout<<"A delete."<<endl;
}
A(const A &a):i(a.i),bigObj(new string(*(a.bigObj))){
cout<<"A copied."<<endl;
}
//建议在类里面写好移动构造函数，解决返回对象时对象拷贝带来的性能开销。
A(A&& a):i(a.i),bigObj(a.bigObj){
a.bigObj=nullptr;
cout<<"A moved."<<endl;
}
};
//如果没有编译器优化，如果没有移动构造函数，这种写法调用拷贝构造函数，产生对象复制
A GetAInstance1(){
A a;
return a;
}
//这种写法运行没问题，但是要在函数调用之后手动释放对象，
//代码管理难度和内存泄漏风险提高。
A* GetAInstance2(){
A* a=new A;
return a;
}
//这种写法没问题
unique_ptr<A> GetAInstance3(){
unique_ptr<A> a(new A);
return a;
}
//这样返回会造成内存泄漏
A GetAInstance4(){
A* a=new A; //此处的a无法释放
return *a;
}
//这样返回会使用不该使用的内存，造成程序运行不稳定
A* GetAInstance5(){
A a;
return &a;
}
int main(int argc, const char * argv[]) {
A a1=GetAInstance1();
cout<<"-----------------"<<endl;
A* a2=GetAInstance2();
delete a2;
cout<<"-----------------"<<endl;
unique_ptr<A> a3=GetAInstance3();
cout<<"Main Over"<<endl;
return 0;
}
|
原文转自：https://www.jb51.net/article/266843.htm
标签：返回,const,对象,C++,int,引用,Time,bigObj From： https://www.cnblogs.com/zhuchunlin/p/16933686.html