數組名和數組名取地址的區別


 

以下代碼會打印出什么樣的日志呢?

[cpp]   view plain copy
  1. #include <stdio.h>  
  2.   
  3. int a[2] = {1,2};  
  4. int main(){  
  5.         printf("a = %p\n", a); // I  
  6.         printf("&a = %p\n", &a); // II  
  7.         printf("a + 1 = %p\n", a + 1);// III  
  8.         printf("&a + 1 = %p\n", &a + 1);// IV  
  9.   
  10.         return 0;  
  11. }  
本機(linux)結果輸出:
a = 0x804a014
&a = 0x804a014
a + 1 = 0x804a018
&a + 1 = 0x804a01c
沒錯,上面I 和 II打印出來的地址是一樣的,IV 要比 III 大4個字節的地址空間。下面是我對這一現象的解釋,如有不妥的地方請各位大蝦一定給於指出:
首先引用《C和指針》p141中的理論: 在C中, 在幾乎所有使用數組的表達式中,數組名的值是個指針常量,也就是數組第一個元素的地址。 它的類型取決於數組元素的類型: 如果它們是int類型,那么數組名的類型就是“指向int的常量指針“。 看到這里我想應該就知道為什么 會有I 和 III式的結果了。
對於II 和 IV 則是特殊情況,在《C和指針》p142中說到,在以下兩中場合下,數組名並不是用指針常量來表示,就是當數組名作為sizeof操作符和單目操作符&的操作數時。 sizeof返回整個數組的長度,而不是指向數組的指針的長度。 取一個數組名的地址所產生的是一個指向數組的指針,而不是一個指向某個指針常量的指針。 所以&a后返回的指針便是指向數組的指針,跟a(一個指向a[0]的指針)在指針的類型上是有區別的。
然后我們用符號表和匯編代碼來看看編譯器到底是怎樣區分&a 和 a, 並將其轉換為匯編代碼的
通過 nm a.out 得到符號表如下:

 

[plain]   view plain copy
  1. 。。。。。。。// 省略了一些與本主題無關的變量  
  2. 0804a01c A _edata  
  3. 0804a024 A _end  
  4. 080484ec T _fini  
  5. 08048508 R _fp_hw  
  6. 080482bc T _init  
  7. 08048330 T _start  
  8. 0804a014 D a // a 變量保存在虛擬地址0x0804a014 中  
  9. 0804a01c b completed.7021  
  10. 0804a00c W data_start  
  11. 0804a020 b dtor_idx.7023  
  12. 080483c0 t frame_dummy  
  13. 080483e4 T main // main函數的地址  
  14.          U printf@@GLIBC_2.0  

調用gcc -S xx.c得到匯編代碼:

[cpp]   view plain copy
  1.     .file   "name_of_array.c"  
  2. .globl a  
  3.     .data  
  4.     .align 4  
  5.     .type   a, @object  
  6.     .size   a, 8 // 從這里我們便知道sizeof(a) 等於8  
  7. a:  
  8.     .long   1 // 從這里可以看出,編譯器直接把 .c文件中的int 轉化為long型  
  9.     .long   2  
  10.     .section    .rodata  
  11. .LC0:  
  12.     .string "a = %p\n"  
  13. .LC1:  
  14.     .string "&a = %p\n"  
  15. .LC2:  
  16.     .string "a + 1 = %p\n"  
  17. .LC3:  
  18.     .string "&a + 1 = %p\n"  
  19.     .text  
  20. .globl main  
  21.     .type   main, @function  
  22. main:  
  23.     pushl   %ebp  
  24.     movl    %esp, %ebp  
  25.     andl    $-16, %esp  
  26.     subl    $16, %esp  
  27.     movl    $.LC0, %eax // I 所對應的匯編代碼  
  28.     movl    $a, 4(%esp)  
  29.     movl    %eax, (%esp)  
  30.     call    printf  
  31.     movl    $.LC1, %eax // II 所對應的匯編代碼  
  32.     movl    $a, 4(%esp)  
  33.     movl    %eax, (%esp)  
  34.     call    printf  
  35.     movl    $.LC2, %eax // III 所對應的匯編代碼  
  36.     movl    $a+4, 4(%esp)  
  37.     movl    %eax, (%esp)  
  38.     call    printf  
  39.     movl    $a+8, %edx // IV 所對應的匯編代碼  
  40.     movl    $.LC3, %eax  
  41.     movl    %edx, 4(%esp)  
  42.     movl    %eax, (%esp)  
  43.     call    printf  
  44.     movl    $0, %eax  
  45.     leave  
  46.     ret  
  47.     .size   main, .-main  
  48.     .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"  
  49.     .section    .note.GNU-stack,"",@progbits  
I所對應的匯編代碼 movl $a, 4(%esp) $表示取地址,通過符號表我們知道a對應地址為0x0804a014, 所以這段代碼將會打印0x0804a014。但是我們明明在代碼里寫的是printf("a = %p\n", a), (如果a不為數組名而是一般意義的int變量,相應的匯編碼應為movl a, 4(%esp) 怎么編譯后的匯編代碼會是對a取地址呢? 本人猜測為編譯器自動給a 加了一個取值符,從而翻譯為$a。 結論: 對於用戶沒有明確給出&的編碼,編譯器翻譯自動給變量a加上取值符$, 其中取a的地址得到的指針類型由數組元素決定。

II 略過

III movl $a+4, 4(%esp) 對a加上取值符得到$a,因為數組元素類型為int,所以指針每次需要移動四個字節的地址空間。 所以c代碼 a + 1 翻譯為匯編 $a + 4 
IV  movl $a+8, %edx  所對應用戶代碼為printf("a = %p\n", &a + 1), 根據《C和指針》中的理論,當a前面有&操作符時,編譯器將會把a對應符號表中的地址看作指向數組的指針,sizeof(a) 為8, 從而&a + 1 將會翻譯為$a + 8 結論: 對於用戶明確給出&的編碼,編譯器將會把取a的地址得到的指針類型看作指向數組的指針。

總結:編譯器通過用戶是否給出&,來決定指針變量的類型,進而翻譯為相應的匯編碼。 或者換句話說,&符只是用來表明變量a取地址后得到的值,被看作什么類型的指針,而不是用來表示對a進行取地址操作。


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM