看下面程式碼：

int  main()
{
	int a[5]={3,6,4,2,5};
	char *ptrChar="hello world";//ptrChar是char型別的指標，指向記憶體空間
	int *ptrInt=a;//ptrInt是指向int型別的指標
	printf("sizeof(char):%d\n",sizeof(char));
	printf("sizeof(int):%d\n",sizeof(int));
        printf("sizeof(ptrChar):%d\n",sizeof(ptrChar));
	printf("sizeof(ptrInt):%d\n",sizeof(ptrInt));
	printf("value of ptrChar is:%d\n",ptrChar);
	printf("value of (ptrChar+1) is:%d\n",ptrChar+1);
	printf("value of ptrInt is:%d\n",ptrInt);
	printf("value of (ptrInt+1) is:%d\n",ptrInt+1);
	system("pause");
	return 1;
}
 

程式執行結果如下：

從程式的執行結果可以得出：

指標本身是一個變數，它所儲存的是另一個變數的地址，指標變數所佔的記憶體是4個位元組，這與它所指向的變數所佔的記憶體空間大小是沒有關係的，指標變數本身和它所指向的記憶體空間是完全獨立的。

在原始碼級別上對指標變數+1，編譯器內部增加的值是該指標所指向的變數的寬度，這種優化避免了指標指向一個不完整的地址。

下面的程式碼：

void arraySort(int num[5],int lenth)
{
	int i,j,temp;
	int tmpLenth=sizeof(num)/sizeof(num[0]);
	printf("tmpLenth:%d\n",tmpLenth);
	for(i=0;i<lenth;i++)
	{
		for(j=i+1;j<lenth;j++)
		{
			if(num[i]>num[j])
			{
				temp=num[i];
				num[i]=num[j];
				num[j]=temp;
			}
		}
	}
}
void displayArray(int num[5],int lenth)
{
	int i;
	for(i=0;i<lenth;i++)
	{
		printf("%d\t",num[i]);
	}
	printf("\n");
}
int main()
{
	
	int a[5]={3,6,4,2,5};
	int lenth=sizeof(a)/sizeof(a[0]);//a是陣列名，也是陣列的首地址，sizeof(a)是整個陣列所佔的記憶體空間的大小
	printf("lenth:%d\n",lenth);
	printf("origin:");
	displayArray(a,lenth);
	arraySort(a,lenth);
	printf("final:");
	displayArray(a,lenth);
	system("pause");
	return 1; 
}
 

執行結果：

這裡，陣列做函式引數，執行結果發現函式內sizeof(num)/sizeof(num[0])的結果是1，就是說傳過來的引數根本不是陣列。這裡如果真的把陣列作為函式引數的話，需要分配臨時的棧區執行拷貝等操作，所以編譯器對程式碼進行了優化，把陣列退化成了指標，因為指標做函式引數本身就是C語言的精華所在。這裡的引數寫成num[5],但是編譯器在優化的時候會直接忽略中括弧裡的數，常見的寫法是不寫括弧裡的數：num[],或者直接寫成指標*pNum。