数组和指针寻址

本节讲述的是指针是如何汇编的。

1：数组和字符数组是如何保存的

先来看看C语言源码

#include<stdio.h>

int main()
{
	int int_a[5]={1,2,3,4,5};

	char char_a[] = "hello world";
	char * char_pa = "hello world";
}

以下是汇编后的代码

; File d:\ѧϰ\c++ anti asm\capter08\main.c
CONST	SEGMENT
??_C@_0M@BNI@hello?5world?$AA@ DB 'hello world', 00H	; `string'   常量存储区
CONST	ENDS
;	COMDAT _main
_TEXT	SEGMENT
_int_a$ = -20	;标识偏移
_char_a$ = -32   
_char_pa$ = -36
_main	PROC NEAR					; COMDAT

; 4    : {

	push	ebp
	mov	ebp, esp
	sub	esp, 100				; 00000064H
	push	ebx
	push	esi
	push	edi
	lea	edi, DWORD PTR [ebp-100]
	mov	ecx, 25					; 00000019H
	mov	eax, -858993460				; ccccccccH
	rep stosd

; 5    : 	int int_a[5]={1,2,3,4,5};     

	mov	DWORD PTR _int_a$[ebp], 1       ; _int_a 的偏移为 -20  依次将5个数拷贝到int型数组的数据区

	mov	DWORD PTR _int_a$[ebp+4], 2
	mov	DWORD PTR _int_a$[ebp+8], 3
	mov	DWORD PTR _int_a$[ebp+12], 4
	mov	DWORD PTR _int_a$[ebp+16], 5

; 6    : 
; 7    : 	char char_a[] = "hello world";	  ； char_a 的偏移为  -32  依次将字符串常量拷贝的到这个数据区



	mov	eax, DWORD PTR ??_C@_0M@BNI@hello?5world?$AA@    
	mov	DWORD PTR _char_a$[ebp], eax
	mov	ecx, DWORD PTR ??_C@_0M@BNI@hello?5world?$AA@+4
	mov	DWORD PTR _char_a$[ebp+4], ecx
	mov	edx, DWORD PTR ??_C@_0M@BNI@hello?5world?$AA@+8
	mov	DWORD PTR _char_a$[ebp+8], edx

; 8    : 	char * char_pa = "hello world";	   ； char_a 的偏移为  -36   将字符串常量的地址拷贝到这个数据区


	mov	DWORD PTR _char_pa$[ebp], OFFSET FLAT:??_C@_0M@BNI@hello?5world?$AA@ ; `string'

; 9    : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
_main	ENDP
_TEXT	ENDS
END

由上对应可知：

int int_a[5]={1,2,3,4,5};

int型数组在栈中的分布是以  int_a 变量的地址依次放置的。位置为 ebp-20 到 ebp-4

char char_a[] = "hello world";

char型数组在栈中的分布同 int型数组类似也是在栈中依次放置的，开辟的空间为 ebp-32 到 ebp-24

char * char_pa = "hello world";

指针赋值的时候仅预留4字节的指针地址空间，初始化的时候仅仅将常量的地址拷贝到该地址

2：数组是如何作为参数和返回值的

请先看源码

#include<stdio.h>
#include<string.h>
char * show( char szBuff[])
{
	strcpy(szBuff,"Hello");
	return szBuff;
}

int main()
{
	char char_a[] = "hello world";
	
	printf("%s\n", show(char_a));
	return 0;
}

汇编以后，这部分是 show函数的代码

PUBLIC	_show
PUBLIC	??_C@_05DPEH@Hello?$AA@				; `string'
EXTRN	_strcpy:NEAR
EXTRN	__chkesp:NEAR
;	COMDAT ??_C@_05DPEH@Hello?$AA@
; File D:\ѧϰ\C++ anti asm\Capter08\main.c
CONST	SEGMENT
??_C@_05DPEH@Hello?$AA@ DB 'Hello', 00H			; `string'   ;常量
CONST	ENDS
;	COMDAT _show
_TEXT	SEGMENT
_szBuff$ = 8	偏移
_show	PROC NEAR					; COMDAT

; 4    : {

	push	ebp
	mov	ebp, esp
	sub	esp, 64					; 00000040H
	push	ebx
	push	esi
	push	edi
	lea	edi, DWORD PTR [ebp-64]
	mov	ecx, 16					; 00000010H
	mov	eax, -858993460				; ccccccccH
	rep stosd

; 5    : 	strcpy(szBuff,"Hello");

	push	OFFSET FLAT:??_C@_05DPEH@Hello?$AA@	; `string'  取常量首地址入栈作为 strcpy 的第一个参数
	mov	eax, DWORD PTR _szBuff$[ebp]     ；获取 show 函数实参 szBuff的地址，这个地址是main函数中调用show函数中时入栈的，具体的函数调用栈请看我此类型文章的第一篇函数的工作原理

	push	eax
	call	_strcpy
	add	esp, 8

; 6    : 	return szBuff;

	mov	eax, DWORD PTR _szBuff$[ebp]   ;返回时，将szBuff的地址放入了寄存器 eax

; 7    : }

	pop	edi
	pop	esi
	pop	ebx
	add	esp, 64					; 00000040H
	cmp	ebp, esp
	call	__chkesp
	mov	esp, ebp
	pop	ebp
	ret	0
_show	ENDP
_TEXT	ENDS

现在来看一下main函数中调用的过程

; 13   : 	printf("%s\n", show(char_a));

	lea	eax, DWORD PTR _char_a$[ebp]   ；这里获得 char_a 数组的首地址

	push	eax
	call	_show
	add	esp, 4
	push	eax
	push	OFFSET FLAT:??_C@_03HHKO@?$CFs?6?$AA@	; `string'
	call	_printf
	add	esp, 8

现在总结一下：在使用数组作为参数时，数组退化为指针，传入被调用函数的是一个指针，如果大家测试 sizeof(szBuff)会发现输出的为4，所以大家在写代码时要避免如下情况

void test(char szBuff[])
{
      int nLen = 0;
      nLen = sizeof(szBuff);  //错误
      nLen = strlen(szBuff); //正确
}

3：如何通过下标和指针寻址

通过上面实例测试我们已经发现 数组名其实就是数组的首地址;

比如 int a[10]; 那么 a[4]实际的地址 即 &a + 4*sizeof(int);

那么 指针是如何寻址的呢其实很简单，因为 一个指针里保存的是数组首地址，所以在汇编代码中，先通过指针获得数组的首地址，然后过的过程就和通过下标寻址一致了，所以指针寻址比通过数组的下标寻址多执行一条指令

4：经过了前面的积累，让我们来看一下相对复杂的多维数组

#include<stdio.h>
#include<string.h>
int main()
{
	int nTwoA[2][2] = {1,2,3,4};
	int i,j;
	printf("%d\n",nTwoA[1][1]);
	
	return 0;
}

; 5    : 	int nTwoA[2][2] = {1,2,3,4};

	mov	DWORD PTR _nTwoA$[ebp], 1
	mov	DWORD PTR _nTwoA$[ebp+4], 2
	mov	DWORD PTR _nTwoA$[ebp+8], 3
	mov	DWORD PTR _nTwoA$[ebp+12], 4

可知在二维数组的初始化时和普通的一维数组是一致的，那二维数组的元素是如何访问的呢

; 8    : 	printf("%d\n",nTwoA[i][j]);

	mov	edx, DWORD PTR _i$[ebp]    ;获取 i的值
	lea	eax, DWORD PTR _nTwoA$[ebp+edx*8]  ；
	mov	ecx, DWORD PTR _j$[ebp]
	mov	edx, DWORD PTR [eax+ecx*4]
	push	edx
	push	OFFSET FLAT:??_C@_03HMFC@?$CFd?6?$AA@	; `string'
	call	_printf
	add	esp, 8

由以上代码可知，元素访问的过程是先 获取i 的值， 然后获取 第一维的偏移量， edx*8 ,因为第二维有2个数，所以应该乘以8，

然后获取j 的值，然后在第一次偏移的基础上获取第二维的偏移量 ecx*4

说了这么多，现在给大家提出几个问题：

1：指向字符串的指针数组是怎么存放的呢 如 char *p[10]; （提示，这说白了还是指针，所以存放的只有地址）

2: char a[2][2]; char *pp = a; char b = pp[1][1]; 访问 pp[1][1] 的过程需要几次寻址操作 （提示3次）

3；函数指针呢？ （提示函数指针是不是也是指针，所以这个指针存放的肯定是函数的地址了，呵呵，所以调用的时候肯定是个简介调用了）

如果错误，请指正。