深入理解指針(六)

1.sizeof和strlen的對比

1.1 sizeof

在學習操作符的時候，我們學習了 sizeof ， sizeof 計算變量所占內存空間??的，單位是字節，如果操作數是類型的話，計算的是使?類型創建的變量所占內存空間的??。

sizeof是單目操作符，不是函數!

sizeof 只關注占?內存空間的??，不在乎內存中存放什么數據。

比如：

#include <stdio.h>
int main()
{int a = 10;printf("%zd\n", sizeof(a));printf("%zd\n", sizeof a);//兩者輸出結果一致，證明了sizeof不是函數，函數不能去掉（）printf("%zd\n", sizeof(int));return 0;
}

1.2 strlen

strlen 是C語?庫函數，功能是求字符串?度。函數原型如下：

size_t strlen ( const char * str );//返回%zd

char str[]="abcdef";
const char* str="abcdef";//兩者都可以
printf("%zd\n",strlen(str));

統計的是從 strlen 函數的參數 str 中這個地址開始向后， \0 之前字符串中字符的個數。 strlen 函數會?直向后找 \0 字符，直到找到為?，所以可能存在越界查找。

size_t len=strlen("abc\0def");
//返回3

#include<string.h>
#include <stdio.h>
int main()
{char arr1[3] = {'a', 'b', 'c'};//不知道0在哪char arr2[] = "abc";//abc\0printf("%d\n", strlen(arr1));//返回隨機值printf("%d\n", strlen(arr2));//返回3printf("%d\n", sizeof(arr1));//返回3printf("%d\n", sizeof(arr2));//返回4（a b c \0）共四個return 0;
}

1.3 sizeof和strlen的對?

sizeof	strlen
1.sizeof是操作符	1.strlen是庫函數，使?需要包含頭?件 string.h
2.sizeof計算操作數所占內存的 ??，單位是字節	2.strlen是求字符串?度的，統計的是 \0 之前字符的個數
3.不關注內存中存放什么數據	3.關注內存中是否有 \0 ，如果沒有 \0 ，就會持續往后找，可能 會越界

對于sizeof

sizeof括號中有表達式時,()里是不計算的

例如:

int a=8;
short s=4;
printf("%d\n",sizeof(s=a+2));//2
printf("%d\n",s);//4

a跟2都是int類型,把他們賦給short類型,所以sizeof認為它是short類型,所以返回2,但表達式是不進行真實計算的.

原因如下:

c語言是編譯型語言

需要經過編譯鏈接生成可執行程序,sizeof在編譯過程完成,s=a+2在運行過程完成，所以還未到運行過程，程序就已經結束，不會運行到s=a+2這一步.

2.數組和指針筆試題解析

數組名的意義：

1.sizeof(數組名)，這?的數組名表?整個數組，計算的是整個數組的??。

2.&數組名，這?的數組名表?整個數組，取出的是整個數組的地址。

3.除此之外所有的數組名都表??元素的地址。

2.1 ?維數組

int a[] = {1,2,3,4};
printf("%zd\n",sizeof(a));//zizeof(數組名)傳遞的是整個數組，所以結果為16(4*4)--四個整型
printf("%zd\n",sizeof(a+0));//a是首元素地址,沒有單獨存放進sizeof,類型是int *,a+0還是首元素地址（不會真的計算）,是地址就是4(32位)或者8(64位)個字節
printf("%zd\n",sizeof(*a));//a是首元素地址,解引用就是第一個元素,所以是4個字節
printf("%zd\n",sizeof(a+1));//a是首元素地址,類型是int*,+1跳過一個整型-->第二個元素地址，是地址就是4或8個字節
printf("%zd\n",sizeof(a[1]));//a[1]是第二個元素,為4字節
printf("%zd\n",sizeof(&a));//存放的是數組地址,還是4或8
printf("%zd\n",sizeof(*&a));//兩種理解方式(結果為16)//1.&a是取出整個數組的地址,對數組指針解引用訪問數組//2.*和&相互抵消 d等價于(sizeof)
printf("%zd\n",sizeof(&a+1));//跳過整個數組后的位置的地址  依然是地址 4或者8
printf("%zd\n",sizeof(&a[0]));//地址 4或8
printf("%zd\n",sizeof(&a[0]+1));//第二個元素的地址 4或8

對于數組a

a——數組名

a——首元素地址——int*

&a——數組的地址——int(*)[4]

2.2 字符數組

代碼1：

#include <stdio.h>
int main()
{char arr[] = {'a','b','c','d','e','f'};printf("%d\n", sizeof(arr));//數組名單獨放sizeof,計算的是數組大小 6字節(一個char類型一個字節)printf("%d\n", sizeof(arr+0));//地址 4或8printf("%d\n", sizeof(*arr));//arr是首元素地址,*arr為第一個元素,1個字節printf("%d\n", sizeof(arr[1]));//第二個元素 1字節printf("%d\n", sizeof(&arr));//&arr是數組地址，4或8字節  arr——char(*)[6]printf("%d\n", sizeof(&arr+1));//跳過整個數組,指向數組后邊的空間  4或者8printf("%d\n", sizeof(&arr[0]+1));//第二個元素地址  4或8return 0;
}

&arr+1為野指針，但是不使用

代碼2：

#include <stdio.h>
#include <string.h>
int main()
{char arr[] = {'a','b','c','d','e','f'};printf("%d\n", strlen(arr));//arr是首元素地址，數組中沒有\0,會導致越界訪問，所以結果是隨機值printf("%d\n", strlen(arr+0));//同上printf("%d\n", strlen(*arr));//arr是首元素地址，*arr是首元素，就是'a',對應的ASII碼值為97,就相當于把97作為地址傳遞給了strlen，strlen得到的就是野指針,所以該程序錯誤printf("%d\n", strlen(arr[1]));//arr[1]--'b'--98,同上錯誤printf("%d\n", strlen(&arr));//&arr是數組地址，起始位置是第一個元素位置-------隨機值printf("%d\n", strlen(&arr+1));//隨機值printf("%d\n", strlen(&arr[0]+1));//從第二個元素開始向后統計，也是隨機值return 0;//假設第10行隨機值為x,則第11行為x+6,第12行為x-1
}

代碼3：

#include <stdio.h>
int main()
{char arr[] = "abcdef";//a b c d e f \0printf("%d\n", sizeof(arr));//數組總大小7printf("%d\n", sizeof(arr+0));//首元素地址 4或8printf("%d\n", sizeof(*arr));//首元素 1字節printf("%d\n", sizeof(arr[1]));//第二個元素 1字節printf("%d\n", sizeof(&arr));//數組地址 4或8printf("%d\n", sizeof(&arr+1));//4或8printf("%d\n", sizeof(&arr[0]+1));//4或8return 0;
}

代碼4：

#include <stdio.h>
#include <string.h>
int main()
{char arr[] = "abcdef";//a b c d e f \0printf("%d\n", strlen(arr));//6printf("%d\n", strlen(arr+0));//首地址開始向后 \0之前  6printf("%d\n", strlen(*arr));//'a'--97出錯printf("%d\n", strlen(arr[1]));'b'--98出錯printf("%d\n", strlen(&arr));//整個數組地址，也是從第一個元素開始   6printf("%d\n", strlen(&arr+1));//隨機值printf("%d\n", strlen(&arr[0]+1));//第二個元素開始 5return 0;
}

代碼5：

#include <stdio.h>
int main()
{const char *p = "abcdef";//字符常量不能修改printf("%d\n", sizeof(p));//p是指針變量 4或8printf("%d\n", sizeof(p+1));//p是char*類型 +1跳一個字節 是b的地址 4或8printf("%d\n", sizeof(*p));//p的類型是char*  *p的類型就是char 1字節printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0)-->*p-->'a'  1字節 把常量字符串想象成數組，p可以理解為數組名,p[0]就是首元素printf("%d\n", sizeof(&p));//4或8 取出的是p的地址printf("%d\n", sizeof(&p+1));//跳過p后的地址 4或8printf("%d\n", sizeof(&p[0]+1));//地址 4或8return 0;
}

代碼6：

#include <stdio.h>
#include <string.h>
int main()
{char *p = "abcdef";// a b c d e f \0printf("%d\n", strlen(p));//6 往后數printf("%d\n", strlen(p+1));//5printf("%d\n", strlen(*p));//*p就是'a'--97  錯誤printf("%d\n", strlen(p[0]));//p[0]---*（p+0）---*p  錯誤printf("%d\n", strlen(&p));//&p取出的是指針變量p的地址，和字符串"abcdef"關系不大，從p這個指針變量起始位置開始向后數------隨機值printf("%d\n", strlen(&p+1));//隨機值 但不一定為上一行的隨機值+1 因為&p和&p+1之間可能有\0printf("%d\n", strlen(&p[0]+1));//5return 0;
}

2.3 ?維數組

include <stdio.h>
int main()
{int a[3][4] = {0};printf("%d\n",sizeof(a));//a是數組名，單獨放在sizeof內部,計算的是數組大小 3*4*sizeof(int)=48printf("%d\n",sizeof(a[0][0]));//第一個元素 4字節printf("%d\n",sizeof(a[0]));//是第一行數組,數組名單獨放在sizeof中,是第一行數組總大小16printf("%d\n",sizeof(a[0]+1));//arr[0]是第一行數組，但沒單獨放在sizeof，所以是arr[0][0]的地址,+1后是arr[0][1]的地址  是地址就為4或8個字節printf("%d\n",sizeof(*(a[0]+1)));//a[0][1]元素 4個字節printf("%d\n",sizeof(a+1));//a表示首元素地址，a為二維數組，它的首元素為第一行的的地址，a+1則為第二行地址，是地址就是4或者8printf("%d\n",sizeof(*(a+1)));//第二行元素 16printf("%d\n",sizeof(&a[0]+1));//第二行地址 4或8printf("%d\n",sizeof(*(&a[0]+1)));//第二行所有元素 16printf("%d\n",sizeof(*a));//*a為第一行元素 16printf("%d\n",sizeof(a[3]));//無需真實存在，僅通過類型推斷就能算出長度,是第四行元素 16return 0;
}

3.指針運算筆試題解析

3.1 題?1

#include <stdio.h>
int main()
{int a[5] = { 1, 2, 3, 4, 5 };int *ptr = (int *)(&a + 1);printf( "%d,%d", *(a + 1), *(ptr - 1));return 0;
}

輸出結果為2，5

3.2 題?2

//在X86環境下 //假設結構體的??是20個字節 
//程序輸出的結果是啥？ 
struct Test
{int Num;char *pcName;short sDate;char cha[2];short sBa[4];
}*p = (struct Test*)0x100000;
//指針+-整數
int main()
{                          //0x1就是1  0x1是十六進制printf("%p\n", p + 0x1);//結構體指針+1,跳過一個結構體 0x100000+20-->0x100014-->00100014  32位補0printf("%p\n", (unsigned long)p + 0x1);//轉換成整型 整型+1就是+1 0x100000+1-->0x100001printf("%p\n", (unsigned int*)p + 0x1);//0x100000+4-->0x100004-->00100004return 0;
}

3.3 題?3

#include <stdio.h>
int main()
{int a[3][2] = { (0, 1), (2, 3), (4, 5) };//注意題目中()不是{}int *p;p = a[0];// 首元素地址，即第一行地址 其實就是a[0][0]的地址printf( "%d", p[0]);//p[0]-->*(p+0)-->*p 所以答案為1return 0;
}

3.4 題目4

//假設環境是x86環境，程序輸出的結果是啥？ 
#include <stdio.h>
int main()
{int a[5][5];int(*p)[4];//p是一個數組指針,p指向的是4個整型元素p = a;printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);//指針-指針的絕對值是指針之間的元素個數return 0;//p[4][2]等價于*(*(p+4)+2)
}

a的類型是int * [5],p的類型是int * [4]

所以結果為%d打印的值為**-4**,%p打印的值為（補碼）十六進制 把-4轉換成十六進制的補碼 結果為FFFFFFFC

3.5 題目5

#include <stdio.h>
int main()
{int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };int *ptr1 = (int *)(&aa + 1);//&aa是整個數組的地址 +1跳過整個數組 然后強制類型轉換為int*int *ptr2 = (int *)(*(aa + 1));//得到一維數組名aa[1]=&aa[1][0] 第二行數組名表示第二行首元素地址printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));return 0;
}

所以答案為10 5

3.6 題?6

#include <stdio.h>
int main()
{char *a[] = {"work","at","alibaba"};//a是指針數組char**pa = a;//pa是二級指針，指向的是a的首元素地址pa++;printf("%s\n", *pa);//%s打印的是字符串，給一個地址，從這個地址向后打印字符串，直到遇到\0return 0;
}

所以本題答案為at

3.7 題?7

這題為本文章最難的一題，但一旦理解，會有醍醐灌頂之感

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

根據題圖可畫出下圖

對于 printf("%s\n", **++cpp);來說，++cpp拿到c+2的值----也就是c+2的地址 再解引用——————PONIT

然后進行printf("%s\n", *--*++cpp+3);//再次++cpp指向c+1 然后解引用得到c+1 然后進行--操作變為c 再解引用 再加3 指向E 打印ER

  然后運行這一行 printf("%s\n", *cpp[-2]+3);//*cpp[-2]等價于**(cpp-2)  先進行cpp-2 重新指向c+3 解引用得到c+3 再解引用 再+3 指向S 最終輸出ST

最后 printf("%s\n", cpp[-1][-1]+1);//由于上一行代碼沒有改變cpp的值 所有cpp初始還是指向c+1 cpp[-1][-1]等價于*(*(cpp-1)-1)    cpp-1指向c+2 解引用得到c+2 再—1 得到c+1 再解引用 再+1指向E 最終輸出EW