c++ 返回变量和返回变量引用

最新推荐文章于 2024-07-20 22:48:54 发布
最新推荐文章于 2024-07-20 22:48:54 发布
阅读量2.7k 收藏 4
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlian523/article/details/95891888
版权

区别

函数的返回时的主要区别在于，函数体返回值后是否有&，而跟return后面怎么跟的无关。

可以这么认为，return语句和函数体返回值会形成一次赋值关系（作=操作）。

函数返回的是非引用类型时，函数会创建临时对象。

sale add(const sale& lift, const sale& right) {
	//省略
	return sum;
	//函数体返回值后没有&，return会创建局部变量
}

sale& add(const sale& lift, const sale& right) {
	//省略
	return sum;
	//函数体返回值后没有&，return不会创建局部变量，而是返回一个指向sum的引用
}

返回变量

class sale {
public:
	int i = 1;
};

sale add(const sale& lift, const sale& right) {
	sale sum = lift;
	sum.i += right.i;
	cout << &sum<<endl;
	return sum;
}

int main()
{
	sale one;
	sale two;
	const sale& global = add(one, two);
	cout << &global<<endl;
	cout << global.i << endl;
}

由于返回类型为非引用，从下面的汇编也能看出，暂时放到寄存器eax里面的是，一个中间变量。所以，它是一个右值。
如果当上面语句改为sale& global = add(one, two)，直接报错“非常量引用的初始值必须为左值”，编译都通不过。
反汇编如下：

sale add(const sale& lift, const sale& right) {
00D518F0 55                   push        ebp  
00D518F1 8B EC                mov         ebp,esp  
00D518F3 81 EC D0 00 00 00    sub         esp,0D0h  
00D518F9 53                   push        ebx  
00D518FA 56                   push        esi  
00D518FB 57                   push        edi  
00D518FC 8D BD 30 FF FF FF    lea         edi,[ebp-0D0h]  
00D51902 B9 34 00 00 00       mov         ecx,34h  
00D51907 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00D5190C F3 AB                rep stos    dword ptr es:[edi]  
00D5190E A1 04 A0 D5 00       mov         eax,dword ptr [__security_cookie (0D5A004h)]  
00D51913 33 C5                xor         eax,ebp  
00D51915 89 45 FC             mov         dword ptr [ebp-4],eax  
00D51918 B9 08 C0 D5 00       mov         ecx,offset _53BED12A_consoleapplication1@cpp (0D5C008h)  
00D5191D E8 04 F9 FF FF       call        @__CheckForDebuggerJustMyCode@4 (0D51226h)  
	sale sum = lift;
00D51922 8B 45 08             mov         eax,dword ptr [lift]  
00D51925 8B 08                mov         ecx,dword ptr [eax]  
00D51927 89 4D F4             mov         dword ptr [sum],ecx  
	sum.i += right.i;
00D5192A 8B 45 0C             mov         eax,dword ptr [right]  
00D5192D 8B 4D F4             mov         ecx,dword ptr [sum]  
00D51930 03 08                add         ecx,dword ptr [eax]  
00D51932 89 4D F4             mov         dword ptr [sum],ecx  
	cout << &sum<<endl;
00D51935 8B F4                mov         esi,esp  
00D51937 68 53 12 D5 00       push        offset std::endl<char,std::char_traits<char> > (0D51253h)  
00D5193C 8B FC                mov         edi,esp  
00D5193E 8D 45 F4             lea         eax,[sum]  
00D51941 50                   push        eax  
00D51942 8B 0D AC B0 D5 00    mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (0D5B0ACh)]  
00D51948 FF 15 9C B0 D5 00    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D5B09Ch)]  
00D5194E 3B FC                cmp         edi,esp  
00D51950 E8 DB F8 FF FF       call        __RTC_CheckEsp (0D51230h)  
00D51955 8B C8                mov         ecx,eax  
00D51957 FF 15 A4 B0 D5 00    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D5B0A4h)]  
00D5195D 3B F4                cmp         esi,esp  
00D5195F E8 CC F8 FF FF       call        __RTC_CheckEsp (0D51230h)  
	return sum;
00D51964 8B 45 F4             mov         eax,dword ptr [sum]  
}

int main()
{
00D519F0 55                   push        ebp  
00D519F1 8B EC                mov         ebp,esp  
00D519F3 81 EC 00 01 00 00    sub         esp,100h  
00D519F9 53                   push        ebx  
00D519FA 56                   push        esi  
00D519FB 57                   push        edi  
00D519FC 8D BD 00 FF FF FF    lea         edi,[ebp-100h]  
00D51A02 B9 40 00 00 00       mov         ecx,40h  
00D51A07 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00D51A0C F3 AB                rep stos    dword ptr es:[edi]  
00D51A0E A1 04 A0 D5 00       mov         eax,dword ptr [__security_cookie (0D5A004h)]  
00D51A13 33 C5                xor         eax,ebp  
00D51A15 89 45 FC             mov         dword ptr [ebp-4],eax  
00D51A18 B9 08 C0 D5 00       mov         ecx,offset _53BED12A_consoleapplication1@cpp (0D5C008h)  
00D51A1D E8 04 F8 FF FF       call        @__CheckForDebuggerJustMyCode@4 (0D51226h)  
	sale one;
00D51A22 8D 4D F4             lea         ecx,[one]  
00D51A25 E8 AD F6 FF FF       call        sale::sale (0D510D7h)  
	sale two;
00D51A2A 8D 4D E8             lea         ecx,[two]  
00D51A2D E8 A5 F6 FF FF       call        sale::sale (0D510D7h)  
	const sale& global = add(one, two);
00D51A32 8D 45 E8             lea         eax,[two]  
00D51A35 50                   push        eax  
00D51A36 8D 4D F4             lea         ecx,[one]  
00D51A39 51                   push        ecx  
00D51A3A E8 40 F9 FF FF       call        add (0D5137Fh)  
00D51A3F 83 C4 08             add         esp,8  #调用完毕后，清除栈空间
00D51A42 89 85 04 FF FF FF    mov         dword ptr [ebp-0FCh],eax  #为中间变量分配空间
00D51A48 8B 95 04 FF FF FF    mov         edx,dword ptr [ebp-0FCh]  
00D51A4E 89 55 D0             mov         dword ptr [ebp-30h],edx  #把中间变量复制给新的变量
00D51A51 8D 45 D0             lea         eax,[ebp-30h]  #导入新变量的地址
00D51A54 89 45 DC             mov         dword ptr [global],eax  #把这个地址给global，因为引用本质是指针
	cout << &global<<endl;
00D51A57 8B F4                mov         esi,esp  
00D51A59 68 53 12 D5 00       push        offset std::endl<char,std::char_traits<char> > (0D51253h)  
00D51A5E 8B FC                mov         edi,esp  
00D51A60 8B 45 DC             mov         eax,dword ptr [global]  
00D51A63 50                   push        eax  
00D51A64 8B 0D AC B0 D5 00    mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (0D5B0ACh)]  
00D51A6A FF 15 9C B0 D5 00    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D5B09Ch)]  
00D51A70 3B FC                cmp         edi,esp  
00D51A72 E8 B9 F7 FF FF       call        __RTC_CheckEsp (0D51230h)  
00D51A77 8B C8                mov         ecx,eax  
00D51A79 FF 15 A4 B0 D5 00    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D5B0A4h)]  
00D51A7F 3B F4                cmp         esi,esp  
00D51A81 E8 AA F7 FF FF       call        __RTC_CheckEsp (0D51230h)  
	cout << global.i << endl;
00D51A86 8B F4                mov         esi,esp  
00D51A88 68 53 12 D5 00       push        offset std::endl<char,std::char_traits<char> > (0D51253h)  
00D51A8D 8B FC                mov         edi,esp  
00D51A8F 8B 45 DC             mov         eax,dword ptr [global]  
00D51A92 8B 08                mov         ecx,dword ptr [eax]  
00D51A94 51                   push        ecx  
00D51A95 8B 0D AC B0 D5 00    mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (0D5B0ACh)]  
00D51A9B FF 15 A0 B0 D5 00    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D5B0A0h)]  
00D51AA1 3B FC                cmp         edi,esp  
00D51AA3 E8 88 F7 FF FF       call        __RTC_CheckEsp (0D51230h)  
00D51AA8 8B C8                mov         ecx,eax  
00D51AAA FF 15 A4 B0 D5 00    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D5B0A4h)]  
00D51AB0 3B F4                cmp         esi,esp  
00D51AB2 E8 79 F7 FF FF       call        __RTC_CheckEsp (0D51230h)  
}

主函数中改成sale global = add(one, two);，那么汇编的变化为：

010E1A32 8D 45 E8             lea         eax,[two]  
010E1A35 50                   push        eax  
010E1A36 8D 4D F4             lea         ecx,[one]  
010E1A39 51                   push        ecx  
010E1A3A E8 6D F9 FF FF       call        add (010E13ACh)  
010E1A3F 83 C4 08             add         esp,8  
010E1A42 89 85 10 FF FF FF    mov         dword ptr [ebp-0F0h],eax  #分配空间，装入值。但只分配一次空间。
010E1A48 8B 95 10 FF FF FF    mov         edx,dword ptr [ebp-0F0h]  
010E1A4E 89 55 DC             mov         dword ptr [global],edx

主函数中改成const sale global = add(one, two);，汇编和上面这个一样。

返回变量引用

class sale {
public:
	int i = 1;
};

sale& add(const sale& lift, const sale& right) {
	sale sum = lift;
	sum.i += right.i;
	cout << &sum<<endl;
	return sum;
}

int main()
{
	sale one;
	sale two;
	sale& global = add(one, two);
	cout << &global<<endl;
	cout << global.i << endl;
}

返回了局部变量的引用，这种用法肯定是错的，但这里观察汇编代码就好。

sale& add(const sale& lift, const sale& right) {
012B18F0 55                   push        ebp  
012B18F1 8B EC                mov         ebp,esp  
012B18F3 81 EC D0 00 00 00    sub         esp,0D0h  
012B18F9 53                   push        ebx  
012B18FA 56                   push        esi  
012B18FB 57                   push        edi  
012B18FC 8D BD 30 FF FF FF    lea         edi,[ebp-0D0h]  
012B1902 B9 34 00 00 00       mov         ecx,34h  
012B1907 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
012B190C F3 AB                rep stos    dword ptr es:[edi]  
012B190E A1 04 A0 2B 01       mov         eax,dword ptr [__security_cookie (012BA004h)]  
012B1913 33 C5                xor         eax,ebp  
012B1915 89 45 FC             mov         dword ptr [ebp-4],eax  
012B1918 B9 08 C0 2B 01       mov         ecx,offset _53BED12A_consoleapplication1@cpp (012BC008h)  
012B191D E8 04 F9 FF FF       call        @__CheckForDebuggerJustMyCode@4 (012B1226h)  
	sale sum = lift;
012B1922 8B 45 08             mov         eax,dword ptr [lift]  
012B1925 8B 08                mov         ecx,dword ptr [eax]  
012B1927 89 4D F4             mov         dword ptr [sum],ecx  
	sum.i += right.i;
012B192A 8B 45 0C             mov         eax,dword ptr [right]  
012B192D 8B 4D F4             mov         ecx,dword ptr [sum]  
012B1930 03 08                add         ecx,dword ptr [eax]  
012B1932 89 4D F4             mov         dword ptr [sum],ecx  
	cout << &sum<<endl;
012B1935 8B F4                mov         esi,esp  
012B1937 68 53 12 2B 01       push        offset std::endl<char,std::char_traits<char> > (012B1253h)  
012B193C 8B FC                mov         edi,esp  
012B193E 8D 45 F4             lea         eax,[sum]  
012B1941 50                   push        eax  
012B1942 8B 0D AC B0 2B 01    mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (012BB0ACh)]  
012B1948 FF 15 9C B0 2B 01    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (012BB09Ch)]  
012B194E 3B FC                cmp         edi,esp  
012B1950 E8 DB F8 FF FF       call        __RTC_CheckEsp (012B1230h)  
012B1955 8B C8                mov         ecx,eax  
012B1957 FF 15 A4 B0 2B 01    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (012BB0A4h)]  
012B195D 3B F4                cmp         esi,esp  
012B195F E8 CC F8 FF FF       call        __RTC_CheckEsp (012B1230h)  
	return sum;
012B1964 8D 45 F4             lea         eax,[sum]  #这里不一样了，之前是eax装内容，现在是直接装地址。就是相当于返回引用啦。
}


int main()
{
012B19F0 55                   push        ebp  
012B19F1 8B EC                mov         ebp,esp  
012B19F3 81 EC E8 00 00 00    sub         esp,0E8h  
012B19F9 53                   push        ebx  
012B19FA 56                   push        esi  
012B19FB 57                   push        edi  
012B19FC 8D BD 18 FF FF FF    lea         edi,[ebp-0E8h]  
012B1A02 B9 3A 00 00 00       mov         ecx,3Ah  
012B1A07 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
012B1A0C F3 AB                rep stos    dword ptr es:[edi]  
012B1A0E A1 04 A0 2B 01       mov         eax,dword ptr [__security_cookie (012BA004h)]  
012B1A13 33 C5                xor         eax,ebp  
012B1A15 89 45 FC             mov         dword ptr [ebp-4],eax  
012B1A18 B9 08 C0 2B 01       mov         ecx,offset _53BED12A_consoleapplication1@cpp (012BC008h)  
012B1A1D E8 04 F8 FF FF       call        @__CheckForDebuggerJustMyCode@4 (012B1226h)  
	sale one;
012B1A22 8D 4D F4             lea         ecx,[one]  
012B1A25 E8 AD F6 FF FF       call        sale::sale (012B10D7h)  
	sale two;
012B1A2A 8D 4D E8             lea         ecx,[two]  
012B1A2D E8 A5 F6 FF FF       call        sale::sale (012B10D7h)  
	sale& global = add(one, two);
012B1A32 8D 45 E8             lea         eax,[two]  
012B1A35 50                   push        eax  
012B1A36 8D 4D F4             lea         ecx,[one]  
012B1A39 51                   push        ecx  
012B1A3A E8 68 F9 FF FF       call        add (012B13A7h)  
012B1A3F 83 C4 08             add         esp,8  
012B1A42 89 45 DC             mov         dword ptr [global],eax  #既然等号左边也是引用，就把地址传给ptr [global]就好
	cout << &global<<endl;
012B1A45 8B F4                mov         esi,esp  
012B1A47 68 53 12 2B 01       push        offset std::endl<char,std::char_traits<char> > (012B1253h)  
012B1A4C 8B FC                mov         edi,esp  
012B1A4E 8B 45 DC             mov         eax,dword ptr [global]  
012B1A51 50                   push        eax  
012B1A52 8B 0D AC B0 2B 01    mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (012BB0ACh)]  
012B1A58 FF 15 9C B0 2B 01    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (012BB09Ch)]  
012B1A5E 3B FC                cmp         edi,esp  
012B1A60 E8 CB F7 FF FF       call        __RTC_CheckEsp (012B1230h)  
012B1A65 8B C8                mov         ecx,eax  
012B1A67 FF 15 A4 B0 2B 01    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (012BB0A4h)]  
012B1A6D 3B F4                cmp         esi,esp  
012B1A6F E8 BC F7 FF FF       call        __RTC_CheckEsp (012B1230h)  
	cout << global.i << endl;
012B1A74 8B F4                mov         esi,esp  
012B1A76 68 53 12 2B 01       push        offset std::endl<char,std::char_traits<char> > (012B1253h)  
012B1A7B 8B FC                mov         edi,esp  
012B1A7D 8B 45 DC             mov         eax,dword ptr [global]  
012B1A80 8B 08                mov         ecx,dword ptr [eax]  
012B1A82 51                   push        ecx  
012B1A83 8B 0D AC B0 2B 01    mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (012BB0ACh)]  
012B1A89 FF 15 A0 B0 2B 01    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (012BB0A0h)]  
012B1A8F 3B FC                cmp         edi,esp  
012B1A91 E8 9A F7 FF FF       call        __RTC_CheckEsp (012B1230h)  
012B1A96 8B C8                mov         ecx,eax  
012B1A98 FF 15 A4 B0 2B 01    call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (012BB0A4h)]  
012B1A9E 3B F4                cmp         esi,esp  
012B1AA0 E8 8B F7 FF FF       call        __RTC_CheckEsp (012B1230h)  
}

如果在主函数里改成sale global = add(one, two)，那么汇编就会变成：

00381A32 8D 45 E8             lea         eax,[two]  
00381A35 50                   push        eax  
00381A36 8D 4D F4             lea         ecx,[one]  
00381A39 51                   push        ecx  
00381A3A E8 68 F9 FF FF       call        add (03813A7h)  
00381A3F 83 C4 08             add         esp,8  
00381A42 8B 10                mov         edx,dword ptr [eax]  #将引用指向的数据取出到edx
00381A44 89 55 DC             mov         dword ptr [global],edx #再把值放到global

这是因为此时global不是引用（引用本质是指针），所以global直接放值。而之前是sale& global = add(one, two)，所以global放地址。

anlian523
关注
专栏目录
C++返回局部变量引用的具体细节
Hugh的博客
06-04 3644
返回局部变量引用的情况 书上都说不能返回局部变量的引用或局部指针，说这种行为危险，但又没讲具体原因，那么今天就来看看这种行为的具体细节 PS：下面含有AT&T汇编内容，未学过汇编的朋友可以跳过直接看结论 先放一个实验用函数，即返回 int& 类型的局部变量的函数 int& RetInt(){ int i=42; int& RefI=i; return RefI; } 测试函数 稍后会用到的几个测试函数，用来说明不同情况下使用局部的结果 void
C++ 之函数返回局部变量
qq_34385263的博客
08-17 7006
1. 返回字符串字面量的指针，即存放在常量存储区的数据，不会因为函数调用栈被释放而消失，所以操作可行。 char* const_str() { char* p = "Hello World!"; // 指向常量区字符串的指针 return p; } 另外，其实这里写的不规范，C++11 标准要求在字面量指针增加 const，以防止猿们随意改变其内容导致段错误。 2....
C++ 引用（详解引用返回）
qq_62015542的博客
04-02 2922
详解引用返回
关于返回对象或变量的引用（reference）的问题
huangshanchun的专栏
07-28 1163
由于局部的对象或变量是在
c++ 函数返回引用
tecoes的博客
07-20 140
5，由于返回值直接指向了一个生命期尚未结束的变量，因此，对于函数返回值（或者称为函数结果）本身的任何操作，都在实际上，是对那个变量的操作，这就是引入const类型的返回的意义。在类的成员函数中，返回引用的类对象，当然不能是函数内定义的类对象（会释放掉），一般为 this 指向的对象，典型的例子是 string类的赋值函数。可以定义一个和返回值一样的引用类型，来接受函数的返回值，操作此引用值，和直接操作函数的参数是一样的,引用都是使用引用传递；当不希望返回的对象被修改时，返回const引用是正确的。
成员函数返回类成员变量的引用，有存在修改成员变量的值的风险。
专注于C/C++/Linux领域创作
01-26 3909
很多时候我们将函数返回值设置为引用类型，这样可以提高函数返回的效率，而如果我们在类成员方法中这样做了，很可能会出一些问题。 参考如下代码：我们通过设置类成员方法 data() ，本意是想查看类私有变量的数值，为了提高效率我们增加了引用。 class Object { private: int value; public: Object(int x = 10) :value(x) {}; int& data() { return value; } }; int main() { Object
C++类成员函数返回对象及返回引用
weixin_43824348的博客
11-22 6085
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 C++类函数返回类的对象及类的引用一、代码例题二、返回引用三、返回对象 一、代码例题 #include <iostream> using namespace std; class machine; ostream& operator<<(ostream& o,const machine& m); class machine { private: int num; public:
C++函数中返回引用和返回值的区别
a55684471的博客
11-30 816
一、主要讨论下面两个函数的区别： int& at() { return m_data_; } int at() { return m_data_; } 上面两个函数，第一个返回值是int的引用int&，第二个返回值是int，二者的区别是什么呢？ 我们先用一个语句const int& a = mymay.at()...
简单介绍C++中变量的引用
09-03
在C++编程语言中，变量的引用是一种非常重要的特性，它是C++相对于C语言的一个显著扩展。引用可以被看作是变量的别名，一旦一个引用被初始化为某个变量，它就永久地与该变量绑定，不能改变引用的对象。下面我们将...
C++ const引用、临时变量 引用参数详解
01-01
C++引用—临时变量、引用参数和const引用 如果实参与引用参数不匹配，C++将生成临时变量。如果引用参数是const,则编译器在下面两种情况下生成临时变量： 实参类型是正确的，但不是左值 实参类型不正确，但可以转换为...
c++访问私有private成员变量的常用方法
08-24
例如，在上面的代码中，我们定义了 `getXY` 函数，返回私有成员变量 `x` 和 `y` 的引用，然后在 `main` 函数中使用引用来访问这些成员变量。 在实际应用中，我们可能需要在类外部访问私有成员变量。如果类提供了 ...
引用作为返回值
dfuw13072的博客
05-05 181
body, table{font-family: 微软雅黑; font-size: 10pt} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1px ...
C++ 返回引用
godqiao的博客
03-18 589
首先看一下返回值与返回引用之间的区别，函数返回值会创建一个临时变量作为函数返回值的副本，而返回引用则不会产生副本。 1）千万不要返回对局部变量的引用，因为函数结束可能会释放局部变量的空间，因此对局部对象的引用将会指向不确定的内存，同时，指针也是一样，不能指向局部临时对象，否则指针可能变成野指针。 参考文章： https://blog.csdn.net/qq_33266987/ar...
C++函数返回引用
vc43vc的专栏
10-02 4574
注：C++ 有三种传递方式：值传递，指针传递，引用传递 返回 “值” 和返回 “引用” 是不同的 函数返回值时会产生一个临时变量作为函数返回值的副本，而返回引用时不会产生值的副本，既然是引用，那引用谁呢？这个问题必须清楚，否则将无法理解返回引用到底是个什么概念。以下是几种引用情况： 一、千万不要返回局部对象的引用 const string &amp;mainip(const string &a...
C++随笔1 --成员函数、返回引用、运算符重载、内存的堆栈
qq_33310245的博客
08-04 296
C++随笔--成员函数、返回引用、运算符重载、内存的堆栈
返回栈中成员变量引用类型的陷阱
信箱神、得引擎
03-20 1254
当一个类返回成员变量的引用，这种用法很常见，但当这个类在一个栈中被实例化时，就要当心这种用法的陷阱，尤其是一些临时实例的场合 #include class A { public: int a; A(int _a) : a(_a) { std::cout << "A::A()" << std::endl;} ~A() { std::cout << "A::~A()"
C++（1）：成员变量的访问、构造函数的返回
qcyfred的博客
11-17 578
关于“成员函数的访问权限”和“构造函数的返回值”的小常识。
返回内部成员变量的指针
whz_zb的专栏
05-19 2013
1. 不好的方法： 先看代码 #include #include using namespace std; const int CONTEXT_SZ=255; class Test { public: Test() { } ~Test() { } char *getContext(); int setContext(const char *str); pr
C/C++编程：返回类成员的引用和非引用有什么区别
OceanStar的博客
05-25 764
#include <iostream> #include <utility> class MyClass{ public: void print_str(){ std::cout << "str: "<< str << std::endl; } void setStr(std::string Str){ str = std::move(Str); } std::strin
c++引用返回静态变量
最新发布
09-21
在 C++ 中，静态变量是在整个程序执行期间只初始化一次，并且生命周期贯穿于整个程序的。如果你想通过函数返回一个对静态变量的引用，你可以这样做： ```cpp class MyClass { public: static int myStaticVar; // 声明静态变量 // 函数返回静态变量的引用 static int& getMyStaticRef() { return myStaticVar; } }; // 初始化静态变量 (如果未初始化) int MyClass::myStaticVar = 0; int main() { // 调用函数获取并修改静态变量的引用 int& ref = MyClass::getMyStaticRef(); ref += 5; // 修改静态变量值 // 另一处也能看到修改后的值，因为这是同一个引用 std::cout << MyClass::myStaticVar << std::endl; return 0; } ``` 在这里，`getMyStaticRef()` 函数返回的是 `myStaticVar` 的引用，所以在函数外部也可以直接操作这个静态变量。需要注意的是，虽然可以修改引用，但静态变量本身在全局作用域内只有一份，所以对它的修改会影响所有地方。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值