c++返回值

最新推荐文章于 2024-11-14 17:59:23 发布
最新推荐文章于 2024-11-14 17:59:23 发布
阅读量196 收藏
点赞数
文章标签： c/c++ 数据结构与算法 操作系统

这几天一直在给同学讲数据结构和算法的题，讲题的过程中突然想到这函数的返回值究竟是存放在哪的，为什么可以通过函数的调用来直接给变量赋值。仔细想想这 么多年居然没有深究过这个问题，太不应该，于是今天花了些时间来好好研究了一下这个问题。也跟了一些thread，某些前辈的观点是“不应该动不动就提到 寄存器,栈,堆这些较底层的概念。完全可以这样理解:返回值保存在一段临时区域,到下一条语句时,返回值被销毁,所以,如果要继续使用返回值,必须将返回 值赋予其他变量。”这确实不假，但是我觉得这位前辈应该是在透彻理解了内在的机理之后才这么说的，我觉得作为学习过程还是应该深究一下。 

另有一位前辈说“不大于32位的（返回值）在eax中，64位的在edx + eax中。再大就传指针了。” 

那么就拿反汇编代码开刀，验证一下。 

（一）  基础知识 

在看反汇编代码之前，应该有几点要明确一下： 

1. 每个进程对应一个Call Stack（调用栈），而CallStack 又由许多Stack Frame（栈帧）组成，对应每个未完成的函数调用，由系 统分配。(VC调试中默认是会显示调用栈窗口的，越往栈顶的就是越最近调用的函数，黑色显示的就是还未返回的函数调用) 

2.eax, ebx, ecx, edx, esi, edi, ebp, esp等都是X86 汇编语言中CPU上的32位通用寄存器的名称，他们各自的作用如下： 

EAX 是累加器(accumulator)， 它是很多加法乘法指令的缺省寄存器。 

EBX 是基地址(base)寄存器，在内存寻址时存放基地址。 

ECX 是计数器(counter)，是重复(REP)前缀指令和LOOP指令的内定计数器。 

EDX 则一般被用来放整数除法产生的余数。 

ESI/EDI分别是源/目标索引寄存器(source/destinationindex)，在很多字符串操作指令中，DS:ESI指向源串，而ES:EDI指向目标串。 

EBP是基址指针(BASE POINTER)，按照习惯，通常用于界定StackFrame（栈帧）。 

ESP 是堆栈指针，被形象地称为栈顶指针，堆栈的顶部是地址小的区域，压入堆栈的数据越多，ESP也就越来越小。在32位平台上，每压入一个数据，ESP就减少4字节。 

3.windows平台下的Call Stack，从上（高地址）往下（低地址）生长。 

（二）代码分析 

首先我实验的平台是32位版vs2010，程序为Debug版本。 

先试试32位整型的int，C++的实验代码如下： 


[cpp] view plaincopyprint?#include "stdafx.h"    
int minus(int a ,int b)   
{   
         int j=2;   
         return a-b;   
}   
int _tmain(int argc, _TCHAR* argv[])   
{   
         int i=1;   
         int c=minus(3,1);   
         return 0;   
}   

#include "stdafx.h" 
int minus(int a ,int b) 
{ 
         int j=2; 
         return a-b; 
} 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
         int i=1; 
         int c=minus(3,1); 
         return 0; 
} 


在return 0处设置断点，或者直接用system(“pause”)也行。 

调试运行，可以看到反汇编代码如下： 


[cpp] view plaincopyprint?int minus(int a ,int b)   
{   
/*step8 再次将EPB压栈，并将ESP的值放入EPB中，此时ESP指向位置5，EPB也指向位置5，这个位置也正是minus()栈帧的底部,同时又是Main()栈帧的顶部*/   
01091380 push        ebp    
01091381 mov         ebp,esp    
/*step9 作用同step2。此时EPB位置不变，ESP指向位置6*/   
01091383 sub         esp,0CCh    
/*step10 作用同step3。此时EPB位置不变，ESP指向位置7*/   
01091389 push        ebx    
0109138A push        esi    
0109138B push        edi    
/*step11 作用同step4。ESP和EPB位置不变*/   
0109138C lea         edi,[ebp-0CCh]    
01091392 mov         ecx,33h    
01091397 mov         eax,0CCCCCCCCh    
0109139C rep stos    dword ptres:[edi]    
         int j=2;   
/*step12 作用同step5。ESP和EPB位置不变*/   
0109139E mov         dword ptr [j],2    
         return a-b;   
/*step13 将参数a的值放入EAX。然后将参数b的值也传入，在EAX中进行减法，结果存放在EXA中。ESP和EPB位置不变*/   
010913A5 mov         eax,dword ptr [a]    
010913A8 sub         eax,dword ptr [b]    
}   
/*step14 返 回过程。将三个寄存器的值弹出，恢复到调用前的状态。并将EBP的值赋给ESP，此时EBP与ESP都指向位置5，也就是释放了从位置6到位置5的预留空 间。最后弹出EBP的值，使其恢复到调用minus()前的状态，ret语句进行返回，返回到先前压入栈中的返回地址所指向的地址处。此时EPB指向位置 0，ESP指向位置3*/   
010913AB pop         edi    
010913AC pop         esi    
010913AD pop         ebx    
010913AE mov         esp,ebp    
010913B0 pop         ebp    
010913B1 ret   
   
int _tmain(int argc, _TCHAR* argv[])   
{   
/*step1 运 行时库的启动函数mainCRTStartup()调用Main(),正式进入主函数，将EPB压栈，再将ESP的值放入EPB中，此时ESP指向位置 0，EPB也指向位置0，这个位置也正是的Main()栈帧的底部,同时又是mainCRTStartup()栈帧的顶部*/   
010913C0 push        ebp    
010913C1 mov         ebp,esp    
/*step2 将ESP下移0CCh个字节，也就是位置0到位置1之间的空间，这段空间将预留用来存储局部变量，此时ESP指向位置1，EPB指向位置0*/   
010913C3 sub         esp,0D8h    
/*step3 将三个寄存器的值压栈，此时ESP指向位置2，EPB指向位置0*/   
010913C9 push        ebx    
010913CA push        esi    
010913CB push        edi    
/*step4 首 先将位置1的地址放入目标索引寄存器EDI中，stos dwordptr es:[edi]的意思是从累加器EAX传送4个字节（双字），到由EDI作 为指针的目的串中，同时修改EDI以指向串中的下一个单元，前面加上rep代表重复执行，执行次数就是ECX寄存器中的值，而36h*4正好等于 0D8h，所以以下4句的作用就是将刚刚预留的位置0到位置1之间的空间全部赋值为0CCCCCCCCh ，这其实就是int 3断点，以防止意外访问。 ESP和EPB位置不变*/   
010913CC lea         edi,[ebp-0D8h]    
010913D2 mov         ecx,36h    
010913D7 mov         eax,0CCCCCCCCh    
010913DC rep stos    dword ptres:[edi]    
         int i=1;   
/*step5 将1传到局部变量i所在地址中，也就是刚刚预留的那块空间中，i应当是EBP-偏移量的形式。ESP和EPB位置不变*/   
010913DE mov         dword ptr [i],1    
         int c=minus(3,1);   
/*step6 在调用minus()前，按从右到左的顺序将实参压栈。EPB位置不变，ESP指向位置3*/   
010913E5 push        1    
010913E7 push        3    
/*step7 调用minus()，并将下一条语句的地址010913EE压栈，作为返回地址。EPB位置不变，ESP指向位置4*/   
010913E9 call        minus (10911C7h)    
/*step15 从 minus返回。将ESP+8，代表释放前面压入栈中的两个市场（2个4字节），并将EAX中的值（也就是返回值）赋给局部变量c，这里也就证明了当返回 值是32位int类型的时候，返回值确实是暂存在EAX中的。EPB指向位置0，ESP指向位置2*/   
010913EE add         esp,8    
010913F1 mov         dword ptr [c],eax    
         return 0;   
/*step16 准 备返回0给main函数。先对EAX自身做异或运算，EAX变成0，此时返回值才是真正的不存在了。然后将三个寄存器的值弹出，恢复到 mainCRTStartup()调用main()前的状态，接着释放位置1到位置0之间的预留空间。EPB和ESP都指向位置0。再接着通过比较EBP 与ESP的值，检查ESP是否正常。不相等则调用ILT+305指向的异常处理函数，使ESP等于EBP。正常的话就直接弹出EBP，结束main()函 数，返回mainCRTStartup()函数中继续剩下的操作。*/   
010913F4 xor         eax,eax    
}   
010913F6 pop         edi    
010913F7 pop         esi    
010913F8 pop         ebx    
010913F9 add         esp,0D8h    
010913FF cmp         ebp,esp    
01091401 call       @ILT+305(__RTC_CheckEsp) (1091136h)    
01091406 mov         esp,ebp    
01091408 pop         ebp    
01091409 ret     

int minus(int a ,int b) 
{ 
/*step8 再次将EPB压栈，并将ESP的值放入EPB中，此时ESP指向位置5，EPB也指向位置5，这个位置也正是minus()栈帧的底部,同时又是Main()栈帧的顶部*/ 
01091380 push        ebp  
01091381 mov         ebp,esp  
/*step9 作用同step2。此时EPB位置不变，ESP指向位置6*/ 
01091383 sub         esp,0CCh  
/*step10 作用同step3。此时EPB位置不变，ESP指向位置7*/ 
01091389 push        ebx  
0109138A push        esi  
0109138B push        edi  
/*step11 作用同step4。ESP和EPB位置不变*/ 
0109138C lea         edi,[ebp-0CCh]  
01091392 mov         ecx,33h  
01091397 mov         eax,0CCCCCCCCh  
0109139C rep stos    dword ptres:[edi]  
         int j=2; 
/*step12 作用同step5。ESP和EPB位置不变*/ 
0109139E mov         dword ptr [j],2  
         return a-b; 
/*step13 将参数a的值放入EAX。然后将参数b的值也传入，在EAX中进行减法，结果存放在EXA中。ESP和EPB位置不变*/ 
010913A5 mov         eax,dword ptr [a]  
010913A8 sub         eax,dword ptr [b]  
} 
/*step14 返 回过程。将三个寄存器的值弹出，恢复到调用前的状态。并将EBP的值赋给ESP，此时EBP与ESP都指向位置5，也就是释放了从位置6到位置5的预留空 间。最后弹出EBP的值，使其恢复到调用minus()前的状态，ret语句进行返回，返回到先前压入栈中的返回地址所指向的地址处。此时EPB指向位置 0，ESP指向位置3*/ 
010913AB pop         edi  
010913AC pop         esi  
010913AD pop         ebx  
010913AE mov         esp,ebp  
010913B0 pop         ebp  
010913B1 ret 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
/*step1 运 行时库的启动函数mainCRTStartup()调用Main(),正式进入主函数，将EPB压栈，再将ESP的值放入EPB中，此时ESP指向位置 0，EPB也指向位置0，这个位置也正是的Main()栈帧的底部,同时又是mainCRTStartup()栈帧的顶部*/ 
010913C0 push        ebp  
010913C1 mov         ebp,esp  
/*step2 将ESP下移0CCh个字节，也就是位置0到位置1之间的空间，这段空间将预留用来存储局部变量，此时ESP指向位置1，EPB指向位置0*/ 
010913C3 sub         esp,0D8h  
/*step3 将三个寄存器的值压栈，此时ESP指向位置2，EPB指向位置0*/ 
010913C9 push        ebx  
010913CA push        esi  
010913CB push        edi  
/*step4 首 先将位置1的地址放入目标索引寄存器EDI中，stos dwordptr es:[edi]的意思是从累加器EAX传送4个字节（双字），到由EDI作 为指针的目的串中，同时修改EDI以指向串中的下一个单元，前面加上rep代表重复执行，执行次数就是ECX寄存器中的值，而36h*4正好等于 0D8h，所以以下4句的作用就是将刚刚预留的位置0到位置1之间的空间全部赋值为0CCCCCCCCh ，这其实就是int 3断点，以防止意外访问。 ESP和EPB位置不变*/ 
010913CC lea         edi,[ebp-0D8h]  
010913D2 mov         ecx,36h  
010913D7 mov         eax,0CCCCCCCCh  
010913DC rep stos    dword ptres:[edi]  
         int i=1; 
/*step5 将1传到局部变量i所在地址中，也就是刚刚预留的那块空间中，i应当是EBP-偏移量的形式。ESP和EPB位置不变*/ 
010913DE mov         dword ptr [i],1  
         int c=minus(3,1); 
/*step6 在调用minus()前，按从右到左的顺序将实参压栈。EPB位置不变，ESP指向位置3*/ 
010913E5 push        1  
010913E7 push        3  
/*step7 调用minus()，并将下一条语句的地址010913EE压栈，作为返回地址。EPB位置不变，ESP指向位置4*/ 
010913E9 call        minus (10911C7h)  
/*step15 从 minus返回。将ESP+8，代表释放前面压入栈中的两个市场（2个4字节），并将EAX中的值（也就是返回值）赋给局部变量c，这里也就证明了当返回 值是32位int类型的时候，返回值确实是暂存在EAX中的。EPB指向位置0，ESP指向位置2*/ 
010913EE add         esp,8  
010913F1 mov         dword ptr [c],eax  
         return 0; 
/*step16 准 备返回0给main函数。先对EAX自身做异或运算，EAX变成0，此时返回值才是真正的不存在了。然后将三个寄存器的值弹出，恢复到 mainCRTStartup()调用main()前的状态，接着释放位置1到位置0之间的预留空间。EPB和ESP都指向位置0。再接着通过比较EBP 与ESP的值，检查ESP是否正常。不相等则调用ILT+305指向的异常处理函数，使ESP等于EBP。正常的话就直接弹出EBP，结束main()函 数，返回mainCRTStartup()函数中继续剩下的操作。*/ 
010913F4 xor         eax,eax  
} 
010913F6 pop         edi  
010913F7 pop         esi  
010913F8 pop         ebx  
010913F9 add         esp,0D8h  
010913FF cmp         ebp,esp  
01091401 call       @ILT+305(__RTC_CheckEsp) (1091136h)  
01091406 mov         esp,ebp  
01091408 pop         ebp  
01091409 ret  





再试试64位整型的long long，C++的实验代码如下（VC6编译器可能不支持long long）： 


[cpp] view plaincopyprint?#include "stdafx.h"    
   
long long minus(long long a , long long b)   
{   
         int j=2;   
         return a-b;   
}   
int _tmain(int argc, _TCHAR* argv[])   
{   
         int i=1;   
         long long c=minus(3,1);   
         return 0;   
}   

#include "stdafx.h" 

long long minus(long long a , long long b) 
{ 
         int j=2; 
         return a-b; 
} 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
         int i=1; 
         long long c=minus(3,1); 
         return 0; 
} 


反汇编代码如下： 


[cpp] view plaincopyprint?long long minus(long long a ,long long b)   
{   
01351380 push        ebp    
01351381 mov         ebp,esp    
01351383 sub         esp,0CCh    
01351389 push        ebx    
0135138A push        esi    
0135138B push        edi    
0135138C lea         edi,[ebp-0CCh]    
01351392 mov         ecx,33h    
01351397 mov         eax,0CCCCCCCCh    
0135139C rep stos    dword ptres:[edi]    
         int j=2;   
0135139E mov         dword ptr [j],2    
         return a-b;   
<SPAN style="COLOR: #ff0000">013513A5 mov         eax,dword ptr [a]    
013513A8 sub         eax,dword ptr [b]    
013513AB mov         edx,dword ptr[ebp+0Ch]    
013513AE sbb         edx,dword ptr[ebp+14h] </SPAN>   
}   
013513B1 pop         edi    
013513B2 pop         esi    
013513B3 pop         ebx    
013513B4 mov         esp,ebp    
013513B6 pop         ebp    
013513B7 ret    
    
int _tmain(int argc, _TCHAR* argv[])   
{   
013513C0 push        ebp    
013513C1 mov         ebp,esp    
013513C3 sub         esp,0DCh    
013513C9 push        ebx    
013513CA push        esi    
013513CB push        edi    
013513CC lea         edi,[ebp-0DCh]    
013513D2 mov         ecx,37h    
013513D7 mov         eax,0CCCCCCCCh    
013513DC rep stos    dword ptres:[edi]    
         int i=1;   
013513DE mov         dword ptr [i],1    
         long long c=minus(3,1);   
013513E5 push        0    
013513E7 push        1    
013513E9 push        0    
013513EB push        3    
013513ED call        minus (13511C2h)    
013513F2 add         esp,10h    
<SPAN style="COLOR: #ff0000">013513F5 mov         dword ptr [c],eax    
013513F8 mov        dword ptr [ebp-14h],edx </SPAN>   
         return 0;   
013513FB xor         eax,eax    
}   
013513FD pop         edi    
013513FE pop         esi    
013513FF pop         ebx    
01351400 add         esp,0DCh    
01351406 cmp         ebp,esp    
01351408 call       @ILT+305(__RTC_CheckEsp) (1351136h)    
0135140D mov         esp,ebp    
0135140F pop         ebp    
01351410 ret     

long long minus(long long a ,long long b) 
{ 
01351380 push        ebp  
01351381 mov         ebp,esp  
01351383 sub         esp,0CCh  
01351389 push        ebx  
0135138A push        esi  
0135138B push        edi  
0135138C lea         edi,[ebp-0CCh]  
01351392 mov         ecx,33h  
01351397 mov         eax,0CCCCCCCCh  
0135139C rep stos    dword ptres:[edi]  
         int j=2; 
0135139E mov         dword ptr [j],2  
         return a-b; 
013513A5 mov         eax,dword ptr [a]  
013513A8 sub         eax,dword ptr [b]  
013513AB mov         edx,dword ptr[ebp+0Ch]  
013513AE sbb         edx,dword ptr[ebp+14h]  
} 
013513B1 pop         edi  
013513B2 pop         esi  
013513B3 pop         ebx  
013513B4 mov         esp,ebp  
013513B6 pop         ebp  
013513B7 ret  
  
int _tmain(int argc, _TCHAR* argv[]) 
{ 
013513C0 push        ebp  
013513C1 mov         ebp,esp  
013513C3 sub         esp,0DCh  
013513C9 push        ebx  
013513CA push        esi  
013513CB push        edi  
013513CC lea         edi,[ebp-0DCh]  
013513D2 mov         ecx,37h  
013513D7 mov         eax,0CCCCCCCCh  
013513DC rep stos    dword ptres:[edi]  
         int i=1; 
013513DE mov         dword ptr [i],1  
         long long c=minus(3,1); 
013513E5 push        0  
013513E7 push        1  
013513E9 push        0  
013513EB push        3  
013513ED call        minus (13511C2h)  
013513F2 add         esp,10h  
013513F5 mov         dword ptr [c],eax  
013513F8 mov        dword ptr [ebp-14h],edx  
         return 0; 
013513FB xor         eax,eax  
} 
013513FD pop         edi  
013513FE pop         esi  
013513FF pop         ebx  
01351400 add         esp,0DCh  
01351406 cmp         ebp,esp  
01351408 call       @ILT+305(__RTC_CheckEsp) (1351136h)  
0135140D mov         esp,ebp  
0135140F pop         ebp  
01351410 ret   


  

可以发现在进行减法运算和传递返回值时确实发生了变化，说明返回值为64位整型时，会使用EAX和EDX来分别传递返回值的低32位和高32位。 

  

困了，返回值为浮点和超过64位明天接着讨论= =

C++返回值优化：提高函数返回值效率的方法
HackVibe的博客
08-24 262
在C++编程中，函数的返回值往往是一个非常重要的部分，需要进行优化以提高程序的运行效率和性能。在C++编程中，函数的返回值往往是一个非常重要的部分，因为它往往会涉及到程序的运行效率和性能。在下面的代码示例中，我们将介绍这些技术的具体实现方法。它的实现方式非常简单，只需将函数的返回值类型定义为所需变量的引用即可。它的实现方式与返回引用基本相同，只需将函数的返回值类型定义为所需变量的指针即可。函数并将其返回的对象转移给另一个字符串类型的变量，从而取得了其返回值，并在后面的输出语句中打印了该值。
C++函数的返回值（上）
hou09tian的博客
11-17 1685
对于C++有返回值的函数来说，其返回值的类型可以是值类型，也可以是引用类型。 1 返回值为值类型的函数 使用临时对象（temporary object）来保存函数的返回值。函数的返回值用于初始化调用点的一个临时对象，该临时对象就是函数调用的结果。如 int func() { return 1; } int i = func();此时，有一个临时对象用来保存func()函数的返回值1，之后将临
C++之返回值
wszswllnzn_的博客
03-27 376
return返回，其余的值用形参的引用或者指针直接改变。最好用int定义，返回0、1作为函数是否成功运行的标志。2.数组虽然不能被返回，但是可以返回数组指针。返回值不能是局部对象的引用或者指针。可返回静态变量的引用。
C++ 中的返回值
bamei5868的博客
05-07 374
C++中大致有三种返回值：值拷贝（副本），值引用和指针，返回什么类型的值要根据当时情况而定。 如果返回的是大型对象的副本，那么在每一次的函数调用后返回，都会调用该对象类型的拷贝构造函数构造一个新的副本，这是一个耗时的过程。 因此在不需要返回对象副本的时候，尽量返回对象的引用或者指针，与此同时，如果不会改变引用或者指针指向的对象的内容，都加上const限定符。 不论是返回拷贝，...
C++返回值
天道酬勤
04-28 7650
无返回值函数 没有返回值的return语句只能用在返回类型是void的函数中，这类函数在最后一句后面会隐式执行return语句，一个返回类型是void的函数也能使用return加表达式，不过此时这个表达式必须是另一个返回void的函数。 void func1(int value) { std::cout << value << std::endl; } void fun...
C++中返回值
weixin_30242907的博客
06-29 189
函数的返回值用于初始化在调用函数是创建的临时对象。 1、返回值为非引用类型： 会将函数的返回值复制给临时对象。跟实参初始化形参的方式一样。 2、返回值为引用类型： 没有复制返回值，返回的是对象本身。返回引用时，在函数的参数中要有以引用方式或指针方式传入的要返回的参数 不能返回局部对象的引用。（因为函数执行结束，将释放分配给局部对象的存储空间，对局部对...
C++函数返回值
wywbzan的博客
07-28 293
原文链接：https://blog.youkuaiyun.com/kwsy2008/article/details/49530549
C++ 返回值优化 RVO
Dong_HFUT的博客
04-04 6380
C++ 返回值优化 RVO引子返回值优化 RVORVO 限制参考 在调试 C++ 拷贝和移动系列构造函数时候，发现构造函数调用和预期不太一样，经过查阅相关资料，发现是返回值优化（RVO）从中做梗。了解了事实真相后，今天就和大家聊聊这个 RVO。 引子 直接看一个例子： #include <iostream> class A { public: A (){ std::cout << "A(): addr= " << this << st
关于c++ 返回值的类型定义选择及使用
oxeniu的专栏
01-10 516
3.需要返回内部对象时，返回值设置为const引用，并将接受该对象的对象也定义为const引用，否则会带来复制构造的开销；（见[123]~[127]输出结果）1.方法需要返回新对象时，返回值不能是引用类型，否则某些情况下会出问题；（见[130]输出结果，返回值已被析构）2.尽量在return语句创建返回的对象，否则会带来移动复制和析构的开销；（见[124]~[130]输出结果）4.在需要返回值时定义并调用获取对象的方法，否则会带来移动赋值的开销；（见[129]~[133]输出结果）
C++返回值拷贝以及std::move
FirMoonLight的博客
08-15 1810
我将以下面的类为例子，说明C++在RVO的情况下以及关闭RVO情况下，其函数返回值是如何返回给调用者的，并给出其汇编代码的说明。环境是Ubuntu Linux，编译器为GCC7.5.0。public:Obj() { // 构造函数}}Obj(const Obj &obj) { // 拷贝构造函数}Obj(const Obj &&obj) { // 移动构造函数}Obj &operator=(const Obj &obj) { // 赋值构造函数}...
深度解读《深度探索C++对象模型》之C++返回值优化
iShare_Carlos的博客
04-19 1272
返回值优化是什么意思？编译器在什么情况下会启用返回值优化，返回值优化能获得多少性能的提升？它有什么优缺点？本篇将从背后的机制来深入分析。
C++函数返回值介绍（含return 0 与 return 1 与 return -1介绍）
水亦心的博客
10-15 6万+
很多人在学习C++ 的过程中应该会留意到返回值的问题，特别是习惯用：int main()  的猿类同伴们。我们需要在函数结尾写个返回值。 int main(){ return 0; } 接下来就给大家简单介绍一下返回值。 一、返回值类型 C++函数可以返回多种类型，大致可分4种： 1. 返回void(无返回值)； 2. 返回对象(内置类型对象和自定义对象)； 3. 返回指针(...
c++ 函数返回引用
热门推荐
keyouan2008的专栏
07-17 7万+
c++ 返回函数引用
c++函数返回值
li_unit的博客
08-04 469
const string getStr() { return "aaaa"; } char &get_val(string &str, string::size_type ix) { return str[ix]; } int odd[]{1,2,3,4,5}; int even[]{6,7,8,9,0}; //decltype：并不负责把数组类型转换成对...
C++函数的返回值
weixin_73931631的博客
11-14 420
如果函数返回一个局部变量的引用，这可能会导致未定义的行为，因为局部变量在函数返回后会被销毁，从而导致引用悬空（dangling reference）。：当函数准备返回时，返回值会被拷贝到一个临时的内存区域，这个内存区域通常是调用者的栈帧中。：当函数返回一个局部对象时，编译器会尽量避免拷贝构造函数的调用，而是直接在调用者的内存位置构造该对象。此时返回的是栈上的某个变量的引用或对象的引用，而不是值的副本。：当函数返回一个引用时，返回的值是栈上某个变量的地址，调用者能够通过这个引用直接访问该变量。
c++ 函数的返回值
William
08-18 7858
函数返回值 不要返回局部对象的引用或者指针 引用返回左值，其他返回类型得到右值 main函数返回值中，0表示成功，其他表示识别。 列表初始化返回值 c++ 11新标准规定， 函数可以返回花括号包围的值列表。其实，就是使用列表初始化的方式对表示函数返回的临时变量进行初始化。 vector&lt;string&gt; process() { return {"funca",...
【C++】函数返回值
onlyongwang的博客
06-02 8721
如果我想用void类型的函数，计算给定半径的圆面积，该怎么计算呢，像这样可以吗：答案是不可以的，这样写的话，函数不会把计算好的结果返回到实参，也就是说，函数传递了实参的值到形参的位置，并且在函数那块的地址对这两数进行了处理，却没有把结果返回实参的位置，实参还会保持原先的值不变。那么我想让实参的值也改变该怎么做呢？这时候需要按引用传递函数，也就是说，在编译的时候会让处理器不要把实参的值传递给形参，而...
c++返回值不同是不是重载
最新发布
04-02
<think>嗯，用户问的是“C++返回值不同是不是重载”。首先，我需要确认用户的问题到底是什么。他们可能在学习函数重载的时候遇到了疑惑，不确定返回值类型的不同是否构成重载。 根据C++的标准，函数重载的条件是函数名相同，但参数列表不同（参数的类型、个数或顺序不同）。而返回值类型的不同并不作为函数重载的依据。也就是说，如果两个函数只有返回值类型不同，而参数列表完全相同，编译器会报错，认为这是重复定义，而不是合法的重载。 不过，用户可能在实际编程中看到一些特殊情况，或者在某些资料中看到矛盾的例子，所以需要详细解释这一点。同时，用户可能有更深层的疑问，比如为什么返回值类型不能作为重载的条件，或者是否存在例外情况。 接下来，我需要考虑用户可能的背景。可能是一个刚开始学习C++的新手，对函数重载的概念还不是很清楚，或者在编写代码时遇到了相关的错误，想确认原因。他们可能误以为返回值不同就可以重载，导致程序编译失败，所以想弄清楚规则。 此外，用户的问题可能涉及到模板或运算符重载的特殊情况，但一般情况下返回值不同不算重载。需要明确区分这些情况，避免混淆。例如，在模板中，即使返回值不同，如果参数列表不同，也可以形成重载。或者在运算符重载时，某些运算符的返回值类型是固定的，但参数列表不同的话仍然可以重载。 需要给出明确的例子来说明，当仅改变返回值类型时编译器会报错，而改变参数列表则可以正确重载。同时，解释背后的原因，比如函数调用的上下文如何确定使用哪个重载函数，而返回值类型在调用时可能无法被编译器确定，因此不能作为重载的依据。 另外，用户可能想知道是否存在任何例外情况，或者有没有办法绕过这个限制。例如，通过模板元编程或者其他高级技巧，但通常不建议这样做，因为会导致代码难以理解和维护。 总结来说，回答需要明确说明返回值不同不能构成重载，解释标准规定，举例说明正确和错误的情况，并简要讨论可能的例外或相关的高级主题。同时，确保语言通俗易懂，避免使用过多术语，帮助用户建立正确的理解。</think>在C++中，**仅通过返回值类型的不同无法构成函数重载**。以下是详细解释： --- ### 一、函数重载的核心规则 C++函数重载的判定标准是： - **函数名相同**。 - **参数列表不同**（参数类型、个数或顺序不同）。 **返回值类型不同不会触发重载**。若两个函数仅返回值类型不同，编译器会报错： ```cpp int func(int x); // 合法 double func(int x); // 错误！参数列表相同，仅返回值不同（无法重载） ``` --- ### 二、为什么返回值类型不能用于重载？ 1. **调用歧义**： C++函数调用时，**调用方可能忽略返回值**。例如： ```cpp func(10); // 调用的是int func(int)还是double func(int)？ ``` 编译器无法根据调用上下文推断需要哪个版本。 2. **语言设计原则**： 重载决策基于参数类型，而非返回值，这符合C++的类型系统和编译器的解析逻辑。 --- ### 三、例外场景（看似“返回值不同”的特殊情况） #### 1. 模板中的返回值依赖 通过模板或`auto`推导返回值类型时，**参数列表不同**的模板函数可以形成重载： ```cpp template <typename T> T func(T x); // 版本1：返回T类型 template <typename T> double func(T* x); // 版本2：返回double类型（参数列表不同） ``` #### 2. 运算符重载的固定返回值 某些运算符的返回值类型是固定的（如赋值运算符返回左值引用），但**参数类型不同仍可重载**： ```cpp class MyClass { public: MyClass& operator=(int x); // 返回MyClass& MyClass& operator=(double x); // 参数类型不同，合法重载 }; ``` --- ### 四、总结表 | 场景 | 是否构成重载？ | 原因 | |---------------------|---------------|----------------------------------------------------------------------| | 返回值不同，参数相同 | ❌ 否 | 编译器无法区分调用版本 | | 参数不同，返回值不同 | ✅ 是 | 参数列表差异是重载的核心条件 | | 模板/运算符重载 | ✅ 是 | 参数不同或类型推导允许重载（返回值差异是结果，而非重载条件） | --- ### 五、实际代码验证 ```cpp #include <iostream> using namespace std; // 合法重载：参数类型不同 int func(int x) { return x; } double func(double x) { return x; } // 非法重载：仅返回值不同 // int func(char c) { return c; } // double func(char c) { return c; } // 编译错误！ int main() { cout << func(10) << endl; // 调用int版本 cout << func(3.14) << endl; // 调用double版本 return 0; } ``` --- ### 六、扩展思考 如果需要根据返回值类型动态选择逻辑，可以通过以下方式实现： 1. **模板 + 类型推导**： ```cpp template <typename T> T processValue(T x); ``` 2. **多态或策略模式**： 通过派生类或函数对象封装不同行为。 --- **结论**：C++不允许仅通过返回值类型不同实现重载，必须依赖参数列表的差异。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值