（1）引數傳遞

       __stdcall和__cdecl都是函式呼叫約定關鍵字，先給出這兩者的區別，然後舉例項分析：

　　__stdcall：引數由右向左壓入堆疊；堆疊由函式本身清理。

　   __cdecl：引數也是由右向左壓入堆疊；但堆疊由呼叫者清理。

　　下面給出例項分析：

1. #include "stdio.h"
2. #include <iostream>
3. #include <Windows.h>
4. #include <conio.h>
5. usingnamespace std;  
6. int __stdcall Func_stdcall(
   int nParam1, int nParam2)  
7. {  
8.     return 1;  
9. }  
10. int __cdecl Func_cdecl(int nParam1, int nParam2)  
11. {  
12.     return 1;  
13. }  
14. int main()    
15. {  
16.     int a = Func_stdcall(1, 2);  
17.     a = Func_cdecl(1, 2);  
18.     return 0;    
19. }   

　　首先要明確上圖彙編程式碼中幾個指令的作用：

　　1.call：將call下一條指令的EIP壓入堆疊，然後跳到@後標號地址處執行；EIP相當於儲存著當前程式的計數器值。

　　2.ret：將堆疊的當前資料彈出給EIP，然後繼續執行；

　　3.ret n：n表示一個整數，將堆疊的當前資料彈出給EIP，再將ESP的值加上n，然後繼續執行。

　　我們再看彙編程式碼，呼叫Func_stdcall和Func_cdecl時，都是由呼叫者（main函式）將引數壓入堆疊，注意地址0x00401127、0x00401129和0x00401133、0x00401135都是先壓入2，再壓入1，這個順序就是函式引數由右向左的順序。

再注意地址0x0040110F，這是呼叫Func_stdcall時的出口指令，"ret 8"先把EIP的值彈出，然後再將ESP的值加8，相當於執行兩次出棧的操作。因為編譯環境是32位的，呼叫Func_stdcall時壓入的2和1，其實是壓入的兩個32位整數值，剛好佔8個位元組。然後再繼續執行EIP處的指令，此時EIP的值應為0x00401130，為call指令的下一條指令，這條指令是將返回的值賦給變數a。可見，堆疊的清理是由Func_stdcall內部處理的，外部呼叫者並不處理。

　　然後再來看看__cdecl修飾的Func_cdecl，注意地址0x0040111B，只有一個指令“ret”，只將堆疊當前的值彈出給EIP，然後繼續執行。但是在呼叫前已經壓入了兩個32位的整數值，堆疊還沒有被清理。我們再來看看繼續執行的指令，地址0x0040113C處的指令為繼續執行的指令，指令為“add esp,8“，這個很好理解了，直接將esp的值加上8，也相當於執行兩次出棧操作。但這是由呼叫者（main引數）進行的，因此堆疊是由呼叫者進行清理的。

      __stdcall通常用於Windows API中，可見如下程式碼：

1. #define CALLBACK    __stdcall
2. #define WINAPI      __stdcall
3. #define WINAPIV     __cdecl
4. #define APIENTRY    WINAPI
5. #define APIPRIVATE  __stdcall
6. #define PASCAL      __stdcall
7. #define cdecl       _cdecl
8. #ifndef CDECL
9. #define CDECL       _cdecl
10. #endif

　　另外，還要注意的是，如printf此類支援可變引數的函式，由於不知道呼叫者會傳遞多少個引數，也不知道會壓多少個引數入棧，因此函式本身內部不可能清理堆疊，只能由呼叫者清理了。

出自《程式設計師的自我修養-連結、裝載與庫》P299

eax是函式傳遞返回值的一個通道。

1.對於小於4個位元組的資料函式將返回值儲存在eax中。

2.5~8個位元組物件的情況呼叫慣例都是採用eax和edx的聯合返回方式進行。

3.大於8個位元組的返回型別,用一下程式碼測試:

 1 typedef struct big_thing
 2 {
 3     char buf[128];
 4 }big_thing;
 5 
 6 big_thing return_test()
 7 {
 8     big_thing b;
 9     b.buf[] = 0;
10     return b;
11 }
12 
13 int main()
14 {
15     big_thing n = return_test();
16　}

• 首先main函式在棧額外開闢了一片空間，並將這塊空間的一部分作為傳遞返回值的臨時物件，這裡稱為temp
• 將temp物件的地址作為隱藏引數傳遞個return_test函式
• return_test 函式將資料拷貝給temp物件，並將temp物件的地址用eax傳出。
• return_test返回以後,mian函式將eax 指向的temp物件的內容拷貝給n。

如果返回值的型別的尺寸太大，c語言在函式的返回時會使用一個臨時的棧上記憶體作為中轉，結果返回值物件會被拷貝兩次。因而不到萬不得已，不要輕易返回大尺寸物件。

再來看看函式返回一個C++物件會如何：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 struct cpp_obj
 5 {
 6     cpp_obj()
 7     {
 8         cout << "ctor\n";
 9     }
10 
11     cpp_obj(const cpp_obj& c)
12     {
13         cout << "copy ctor\n";
14     }
15 
16     cpp_obj& opearator=(const cpp_obj& rhs)
17     {
18         cout << "operator = \n";
19         return *this;
20     }
21 
22     ~cpp_obj()
23     {
24         cout << "dtor\n";
25     }
26 };
27 
28 cpp_obj return_test()
29 {
30     cpp_obj b;
31     cout << "before return\n";
32     return b;
33 }
34 int main()
35 {
36     cpp_obj n;
37     n = return_test();
38 }

執行後的輸出結果可以得出：函式返回之後，進行了一個拷貝函式的呼叫，以及一次operator=的呼叫，也就是說，仍然產生了兩次拷貝。因此C++的物件同樣會產生臨時物件。

在這段程式碼中我們還能看到在c++返回一個物件時，物件要經過兩次拷貝建構函式的呼叫才能夠完成返回物件的傳遞，1次拷貝到棧上的臨時物件裡，另一次把臨時物件拷貝到儲存返回值的物件裡。在某些編譯器裡，返回一個物件甚至要經過更多的步驟。

為了減少返回物件的開銷，C++提出了返回值優化（RVO）技術，可以將某些場合下的物件拷貝減少一次，例如：

1 cpp_obj return_test()
2 {
3     return cpp_obj();
4 }

目的是直接將物件的構造在傳出時使用的臨時物件上，減少一次複製過程。