c语言 数组进栈,[原创]C语言——数组和简单栈

数组

具有相同属性的，在内存中顺序排列的一组数据。

int nAge1,nAge2,nAge3…nAge49;

int nAge[50] = {0};

上述两实质是相同的，只是数组提供了跟好的管理，将相同的类型的数据组织起来使用。

int nAge1 = 0x19880808;

00324335 mov dword ptr [nAge1],19880808h

int nAget2 = 0x19870707;

0032433C mov dword ptr [nAget2],19870707h

//.............

int nAge50 = 0x19890909;

00324343 mov dword ptr [nAge50],19890909h

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

0032434A mov dword ptr [nAge],1

00324354 mov dword ptr [ebp-0ECh],2

0032435E mov dword ptr [ebp-0E8h],3

00324368 mov dword ptr [ebp-0E4h],4

00324372 mov dword ptr [ebp-0E0h],5

int nHight[50] ;

for (int i = 0; i < sizeof(nAge)/sizeof(nAge[0]); ++i)

{

nHight[i] = i;

*(int*)(nAge+i) = i;

}

for (int i = 0; i < sizeof(nAge)/sizeof(nAge[0]); ++i)

01144363 mov dword ptr [i],0

0114436D jmp wmain+6Eh (114437Eh)

0114436F mov eax,dword ptr [i]

01144375 add eax,1

01144378 mov dword ptr [i],eax

0114437E cmp dword ptr [i],32h

01144385 jae wmain+9Fh (11443AFh)

{

nHight[i] = i;

01144387 mov eax,dword ptr [i]

0114438D mov ecx,dword ptr [i]

01144393 mov dword ptr nHight[eax*4],ecx

*(int*)(nAge+i) = i;

0114439A mov eax,dword ptr [i]

011443A0 mov ecx,dword ptr [i]

011443A6 mov dword ptr nAge[eax*4],ecx

}

两种访问数据的方式效果是相同的，

一维数据的寻址方式为：首地址+下标(偏移个数)，因为指针有类型，知道数据大小

实质还是以首地址做为标杆，偏移下标和类型对应的字节数(BYTE*)首地址 + 类型大小*下标(偏移个数)

int nTemp1 = nHight[20];

int nTemp2 = *(nHight + 20);

int nTemp3 = *((char*)nHight +sizeof(nHight[0]/*sizeof(int)*/)*20);

int nTemp1 = nHight[20];

003343AF mov eax,dword ptr [ebp-170h]

003343B5 mov dword ptr [nTemp1],eax

int nTemp2 = *(nHight + 20);

003343BB mov eax,dword ptr [ebp-170h]

003343C1 mov dword ptr [nTemp2],eax

int nTemp3 = *((char*)nHight + sizeof(nHight[0]/*sizeof(int)*/)*20);

003343C7 movsx eax,byte ptr [ebp-170h]

003343CE mov dword ptr [nTemp3],eax二维数组在内存也是按一维数组的方式顺序存放在连续的内存空间中。

如  int nTest[2][3]

nTest[0][0]  低地址

nTest[0][1]

nTest[0][2]

nTest[1][0]

nTest[1][1]

nTest[1][2]  高地址

//nAryTest[1][2];

nTemp2 = *((char*)nAryTest + sizeof(nAryTest[3])*1 + sizeof(nAryTest[0][0])*2);

nTemp3 = *((int*)nAryTest + 1*3/*整一维的个数*/ + 2/*一维余数*/);

nTemp2 = *((char*)nAryTest + sizeof(nAryTest[3])*1 + sizeof(nAryTest[0][0])*2);

011E1FA8 movsx eax,byte ptr [ebp-1FCh]

011E1FAF mov dword ptr [nTemp2],eax

nTemp3 = *((int*)nAryTest + 1*3 + 2);

011E1FB5 mov eax,dword ptr [ebp-1FCh]

011E1FBB mov dword ptr [nTemp3],eax

用数组实现一个简单的栈

int* g_lpStackTop = NULL;

int* g_lpStackBottom = NULL;

int* g_lpEsp = NULL;

void ShowStack(char* lpInfo, int nShowCount)

{

if (g_lpEsp == g_lpStackBottom)

{

printf(" ====栈底 [%08X]!===\r\n", g_lpEsp);

return ;

}

if (NULL != lpInfo)

{

printf("%s \r\n", lpInfo);

}

for (int i = 0; i < nShowCount; ++i)

{

if (g_lpEsp+i > g_lpStackBottom-1)

break;

if (0 ==i)

printf(" stack:%08X [ %08X ]

else

printf(" stack:%08X [ %08X ]\r\n", g_lpEsp+i, g_lpEsp[i]);

}

}

//初始化栈

bool InitStack(int* lpStack, int nStackSize)

{

if (NULL == lpStack || 0 >= nStackSize)

return false;

g_lpStackTop = lpStack;

g_lpStackBottom = lpStack + nStackSize;

g_lpEsp = g_lpStackBottom;

if ( g_lpStackBottom < g_lpStackTop )

return false;

return true;

}

//push 抬高栈(往低地址)，塞值

bool _push(int nValue)

{

if (g_lpEsp-1 < g_lpStackTop)

return false;

--g_lpEsp;

g_lpEsp[0] = nValue;

}

//值传去，栈指针下移(往高地址移)

int _pop()

{

if (g_lpEsp+1 > g_lpStackBottom)

return false;

++g_lpEsp;

return g_lpEsp[0];

}

//这里没有处理超出的情况

void StackTest()

{

int szStack[100] = {0};

InitStack(szStack, 100);

ShowStack("初始化的栈\r\n", 1);

_push(0x12);

ShowStack("push后的栈", 4);

_push(0x34);

ShowStack("push后的栈", 4);

_push(0x56);

ShowStack("push后的栈", 4);

_push(0x78);

ShowStack("push后的栈", 4);

_pop();

ShowStack("pop后的栈", 4);

_pop();

ShowStack("pop后的栈", 4);

_pop();

ShowStack("pop后的栈", 4);

}