指標的一些筆試題

整型陣列

int a[] = { 1,2,3,4 };//4*4=16
	printf("%d\n", sizeof(a));//16
	printf("%d\n", sizeof(a + 0));//4/8 a + 0 是第一個元素的地址，sizeof(a + 0)計算的是地址的大小
	printf("%d\n", sizeof(*a));//4  *a是陣列的第一個元素，sizeof(*a)計算的是第一個元素的大小
	printf("%d\n", sizeof(a + 1));//4/8 a + 1是第二個元素的地址，sizeof(a+1)計算的地址的大小
	printf("%d\n", sizeof(a[1]));//4 - 計算的是第二個元素的大小

	printf("%d\n", sizeof(&a)); //4/8 - &a雖然陣列的地址，但是也是地址，sizeof(&a)計算的是一個地址的大小
	printf("%d\n", sizeof(* &a));//16 - 計算的陣列的大小
	//&a -- int(*p)[4] = &a;
	printf("%d\n", sizeof(&a + 1));//4/8 - &a + 1 是陣列后面的空間的地址
	printf("%d\n", sizeof(&a[0]));//4/8
	printf("%d\n", sizeof(&a[0] + 1));//4/8

陣列名只有在兩種情況下才代表整個陣列：

1. sizeof(陣列名)------這里的陣列名代表的是陣列的地址，sizeof算的是整個陣列的大小（這里注意括號里只有陣列名時才表示陣列的地址，例如sizeof(a+0)就不代表陣列的地址了）
2. &陣列名------這里代表的是陣列地址

sizeof后面放的引數無非就三種情況：

1. 放的是只有單獨一個陣列名，這里結果時整個陣列的大小(特殊情況)
2. 放的是指標（除了上面的這種情況）回傳的結果是4(32位作業系統）或 8（64位作業系統）
3. 放的是變數，結果是回傳變數型別的大小

字符陣列

char arr[] = { 'a','b','c','d','e','f' };

	printf("%d\n", strlen(arr));//隨機值
	printf("%d\n", strlen(arr + 0));//隨機值
	//printf("%d\n", strlen(*arr));//err
	//printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//隨機值
	printf("%d\n", strlen(&arr + 1));//隨機值-6
	printf("%d\n", strlen(&arr[0] + 1));//隨機值-1

	printf("%d\n", sizeof(arr));//6
	printf("%d\n", sizeof(arr + 0));//4/8
	printf("%d\n", sizeof(*arr));//1
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4/8
	printf("%d\n", sizeof(&arr + 1));//4/8
	printf("%d\n", sizeof(&arr[0] + 1));//4/8

strlen函式傳過去的是指標，回傳值是’\0’前面的所有字符個數，但是arr陣列并沒有’\0’,顧strlen會訪問越界直到遇到’\0’為止，回傳值也就是一個隨機值，

char arr[] = "abcdef";
	//[a b c d e f \0]
	printf("%d\n", strlen(arr));//6
	printf("%d\n", strlen(arr + 0));//6
	//printf("%d\n", strlen(*arr));//err
	//printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//6
	printf("%d\n", strlen(&arr + 1));//隨機值
	printf("%d\n", strlen(&arr[0] + 1));//5


	[a b c d e f \0] 
	printf("%d\n", sizeof(arr));//7
	printf("%d\n", sizeof(arr + 0));//4/8
	printf("%d\n", sizeof(*arr));//1
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4/8  char(*)[7]
	printf("%d\n", sizeof(&arr + 1));//4/8 
	printf("%d\n", sizeof(&arr[0] + 1));//4/8

常量字串

char* p = "abcdef";

	printf("%d\n", strlen(p)); //6 
	printf("%d\n", strlen(p + 1));//5
	printf("%d\n", strlen(*p));//error
	printf("%d\n", strlen(p[0]));//error
	printf("%d\n", strlen(&p));//error &p是char **型別，傳入引數應為char*型別
	printf("%d\n", strlen(&p + 1));//error
	printf("%d\n", strlen(&p[0] + 1)); //5


	printf("%d\n", sizeof(p)); // 4/8
	printf("%d\n", sizeof(p + 1)); // 4/8
	printf("%d\n", sizeof(*p)); //1
	printf("%d\n", sizeof(p[0])); // 1
	printf("%d\n", sizeof(&p)); // 4/8
	printf("%d\n", sizeof(&p + 1));// 4/8
	printf("%d\n", sizeof(&p[0] + 1)); //4/8

我們知道常量字串是把首元素的地址存入指標中，

二維陣列

int a[3][4] = { 0 };

	printf("%d\n", sizeof(a));//48 = 3*4*sizeof(int)
	printf("%d\n", sizeof(a[0][0]));//4 - a[0][0] - 是第一行第一個元素
	printf("%d\n", sizeof(a[0]));//16
	printf("%d\n", sizeof(a[0] + 1));//4 解釋：a[0]作為陣列名并沒有單獨放在sizeof內部，
									//也沒取地址,所以a[0]就是第一行第一個算的地址
									//a[0]+1,就是第一行第二個元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4 - 解釋：*(a[0] + 1)是第一行第二個元素

	printf("%d\n", sizeof(a + 1));//4 - 解釋：a是二維陣列的陣列名，并沒有取地址
	//也沒有單獨放在sizeof內部,所以a就表示二維陣列首元素的地址，即：第一行的地址
	//a + 1就是二維陣列第二行的地址

	printf("%d\n", sizeof(*(a + 1)));//16 解釋：a+1是第二行的地址，所以*（a+1）表示第二行
	//所以計算的就是第2行的大小

	printf("%d\n", sizeof(&a[0] + 1));//4 解釋：a[0]是第一行的陣列名，
	//&a[0]取出的就是第一行的地址,&a[0]+1 就是第二行的地址

	printf("%d\n", sizeof(*(&a[0] + 1)));//&a[0]+1 就是第二行的地址
	//*(&a[0]+1) 就是第二行，所以計算的第二行的地址

	printf("%d\n", sizeof(*a));//16 解釋：a作為二維陣列的陣列名，沒有&，沒有單獨放在sizeof內部
	//a就是首元素的地址，即第一行的地址，所以*a就是第一行，計算的是第一行的大小

	printf("%d\n", sizeof(a[3]));//16 解釋：a[3]其實是第四行的陣列名（如果有的話）
	//所以其實不存在，也能通過型別計算大小的
	printf("%d\n", sizeof(a[-1]));

這里再次解釋一下二維陣列的構造：
如果不是很了解的可以參考一下《關于指標的一些總結》——目錄：陣列指標

int a[3][4]={};  //實際上等價于
int *p[3]={a[0],a[1],a[2]};

a是代表首行陣列的地址，由a[i]=*(a+i)，可知a[i]實際上等于第i行陣列的首元素的地址，而首元素的地址實際上相當于第i行陣列的陣列名，而a[i]作為陣列名單獨放在sizeof內結果是第i行的大小，整個二維陣列實際上就相當于一個存放陣列首元素指標的指標陣列，

搞清楚了上面的關于指標的練習，我們來看幾道筆試題：

筆試題一：

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int* ptr = (int*)(&a + 1);
    printf("%d,%d", *(a + 1), *(ptr - 1));

    return 0;
}

很明顯&a是陣列指標型別，它加一跳過整個陣列

筆試題二：

//由結構體的記憶體對齊可知，該結構體的記憶體為20位元組
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}* p;
//假設p 的值為0x100000， 如下運算式的值分別為多少？
//已知，結構體Test型別的變數大小是20個位元組

int main()
{
	printf("%p\n", p + 0x1);         // 1
	printf("%p\n", (unsigned long)p + 0x1);     //2
	printf("%p\n", (unsigned int*)p + 0x1);     //3
	return 0;
}

這個筆試題實際上考察的是指標的型別的意義，指標型別決定指標的“步伐”有多大，
1 已知p是一個結構體指標，所以它加一記憶體會跳過20個位元組，故結果為：0x10000014
2 指標p被強制型別轉換為無符號長整型，整型加一，結果加一（注意這里已經不是指標了！）顧結果為：0x10000001.
3 指標p被強制型別轉換為整型指標，顧加一記憶體會跳過4個位元組，所以結果為：0x10000004

筆試題三：

#include<stdio.h>
int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int* ptr1 = (int*)(&a + 1);      //1
    int* ptr2 = (int*)((int)a + 1);//2

    printf("%x,%x", ptr1[-1], *ptr2);
    return 0;
}

1 就不用多解釋和前面的題一樣
2 這里指標a被強制轉換成int型別加一后又被強制轉換成int型別指標，實際上指標a向后移動了一位元組，而ptr2指向的內容是什么這就涉及到位元組序——大小端存盤，可以參考文章《資料在記憶體中的存盤——具體在目錄第二個》

筆試題四

#include<stdio.h>
#include<string>

int main()
{
    int a[5][5];
    int(*p)[4];
    p =(int (*)[4]) a;   //1
    printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}

二維陣列一直可以被看成一個指標陣列（存放陣列指標），//1實際上將a地址的值賦給了p，但p指標型別又是一個指向4個元素的指標陣列，所以p每加一跳過一個四個元素的陣列，整個a[5][5]實際上被重新劃分了

從圖中很直觀的看出&p[4][2]和&a[4][2]之間差了四個元素，而指標-指標結果是之間元素的個數，所以答案是: FFFFFFFC -4

筆試題五：

#include <stdio.h>
int main()
{
	const char* a[] = { "work","at","alibaba" };
	const char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

這里a是一個指標陣列，陣列存的是常量字串第一個字符的地址，而a代表的 是首元素的地址，故為一個二級指標，pa++指向了陣列的下個元素也就是常量字串“at”首元素地址的地址，顧列印的結果為at

筆試題六：

#include<stdio.h>
int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;
}

和筆試題五一樣我們知道指標c是一個char **型別存放的是常量字串首字符的地址的地址，
兩個陣列的結構如下圖：

一

printf("%s\n", **++cpp);

指標先自增再兩次解參考，最后得到的是p3的地址，顧列印結果為： POINT

二

printf("%s\n", *-- * ++cpp + 3);

指標cpp先自增再解參考再自減再解參考得到p1，p1+3指向的是E的地址，所以字串從‘E’開始列印，最后結果為：ER

三

printf("%s\n", *cpp[-2] + 3);

cpp[-2]等價于*(cpp-2)，顧運算式也可以寫成 * *(cpp-2)+3,和上面一樣可以得到指向‘S’的指標，結果為：ST

四

printf("%s\n", cpp[-1][-1] + 1);

cpp[-1][-1]等價于*(*(cpp-1)-1),思路和上面一樣，結果為：EW

總結：

關于指標我們一定要注意的是一定要搞清楚指標的型別，因為指標的型別決定了指標的定義還決定了指標加減整數，其次要搞清楚指標的指向，弄清楚這兩點指標的題就可以迎刃而解了，