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

#include <stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));
	//sizeof 內(nèi)部單獨(dú)放置數(shù)組名，計(jì)算整個(gè)數(shù)組的大小，結(jié)果為 4(int類型)*4(元素個(gè)數(shù))=16
	printf("%d\n", sizeof(a + 0));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，此時(shí)數(shù)組名表首元素地址，a+0 依然表示首元素地址
	//故 sizeof 計(jì)算一個(gè)地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*a));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，此時(shí)數(shù)組名表首元素地址，*a 表對(duì)該地址解引用
	//即可得到 a 數(shù)組的第一個(gè)元素，大小為 4(int類型)
	printf("%d\n", sizeof(a + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，此時(shí)數(shù)組名表首元素地址，a+1 表第二個(gè)元素地址
	//故 sizeof 計(jì)算一個(gè)地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(a[1]));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，a[1] 表數(shù)組的第二個(gè)元素，此寫法可轉(zhuǎn)置為 *(a+1)
	//即計(jì)算的結(jié)果是第二個(gè)元素的類型大小，即 4(int類型)
	printf("%d\n", sizeof(&a));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，而是放置了 &a ，表取出整個(gè)數(shù)組的地址
	//故 sizeof 計(jì)算一個(gè)地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*&a));
	//sizeof 內(nèi)部雖然看似沒有單獨(dú)放置數(shù)組名，但是通過 &a 取出整個(gè)數(shù)組地址
	//然后通過 * 找到整個(gè)地址，與 sizeof(a) 沒有差別
	//故這里的 sizeof 計(jì)算的也是整個(gè)數(shù)組的大小，即 4(int類型)*4(元素個(gè)數(shù))=16
	printf("%d\n", sizeof(&a + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&a+1 表取出整個(gè)數(shù)組的地址，并向后跳躍一個(gè)數(shù)組類型的大小
	//即此時(shí)的地址是指向元素 4 的后面一塊 int 類型的內(nèi)存空間
	//故 sizeof 計(jì)算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&a[0]));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&a[0] 表取出數(shù)組第一個(gè)元素的地址
	//故 sizeof 計(jì)算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&a[0] + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&a[0]+1 表取出數(shù)組第一個(gè)元素地址并向后跳躍一個(gè) int 類型的大小
	//故 sizeof 計(jì)算的是地址(指針)的大小為 4 or 8
	return 0;
}

#include <stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

#include <stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };//非字符串?。。。。?！
	printf("%d\n", sizeof(arr));
	//sizeof 內(nèi)部單獨(dú)放置數(shù)組名，故計(jì)算的是整個(gè)數(shù)組的大小
	//即大小為 1(char類型)*6(元素個(gè)數(shù))=6
	printf("%d\n", sizeof(arr + 0));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，arr 表數(shù)組首元素地址，arr+0 亦表示首元素地址
	//故 sizeof 計(jì)算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*arr));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，arr 表數(shù)組首元素地址，*arr 表對(duì)該地址解引用
	//便得到數(shù)組第一個(gè)元素 'a' ，故大小為 1(char類型)
	printf("%d\n", sizeof(arr[1]));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，arr[1] 表數(shù)組第二個(gè)元素，即 'b'
	//故大小為 1(char類型)
	printf("%d\n", sizeof(&arr));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&arr 表取出整個(gè)數(shù)組的地址
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&arr + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&arr+1 表取出整個(gè)數(shù)組的地址并向后跳躍一個(gè)數(shù)組類型的大小
	//即指向元素 'f' 后一個(gè) char 類型的空間
	//故 sizeof 計(jì)算的是地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&arr[0] + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&arr[0]+1 表取出數(shù)組一個(gè)元素的地址并向后跳躍一個(gè) char 類型的大小
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", strlen(arr));
	//strlen 不是 sizeof ，故 arr 表數(shù)組首元素地址，strlen 會(huì)以此地址開始向后尋找 '\0'
	//但此數(shù)組并不包含 '\0' ，故 strlen 的返回值為隨機(jī)值
	printf("%d\n", strlen(arr + 0));
	//strlen 不是 sizeof ，arr+0 表首元素地址，strlen 的返回值也是一個(gè)隨機(jī)值
	printf("%d\n", strlen(*arr));
	//strlen 不是 sizeof ，*arr 表對(duì)數(shù)組首元素地址解引用，得到字符 'a' ，其 ASCLL 碼值為 97
	//strlen 會(huì)以 97 為起始地址向后尋找 '\0' 
	//但個(gè)人理解認(rèn)為：97 是一個(gè)沒有初始化的指針(地址)，即野指針
	//故這里會(huì)報(bào)錯(cuò)
	printf("%d\n", strlen(arr[1]));
	//arr[1] 表數(shù)組的第二個(gè)元素 'b' ，其 ASCLL 碼值為 98
	//strlen 會(huì)以 98 為起始地址向后尋找 '\0'
	//但個(gè)人理解認(rèn)位：98 是一個(gè)沒有初始化的指針(地址)，即野指針
	//故這里依然會(huì)報(bào)錯(cuò)
	printf("%d\n", strlen(&arr));
	//&arr 表取出整個(gè)數(shù)組的地址，strlen 會(huì)以此作為起始地址向后尋找 '\0'
	//這里需要注意，在 strlen 的函數(shù)聲明當(dāng)中，參數(shù)是一個(gè) char* 類型的指針
	//也就是我們雖然傳參時(shí)傳了一個(gè)數(shù)組指針，但是 strlen 接收時(shí)會(huì)自動(dòng)強(qiáng)轉(zhuǎn)為 char* 類型指針
	//故數(shù)組并不包含 '\0' ，strlen 的返回值是一個(gè)隨機(jī)值
	printf("%d\n", strlen(&arr + 1));
	//&arr+1 表取出整個(gè)數(shù)組的地址并向后跳躍一個(gè)數(shù)組類型的大小
	//即指向了元素 'f' 的后一塊 char 類型的空間
	//strlen 會(huì)以此地址作為起始地址向后尋找 '\0'
	//但因我們無法確定 '\0' 的位置，所以 strlen 的返回值是一個(gè)隨機(jī)值
	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]+1 表取出數(shù)組首元素地址并向后跳躍一個(gè) char 類型的大小
	//即指向了元素 'b' ,strlen 會(huì)以此地址作為起始地址向后尋找 '\0'
	//但數(shù)組中并不包含 '\0' ，故 strlen 的返回值是一個(gè)隨機(jī)值
	return 0;
}

#include <stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

#include <stdio.h>
int main()
{
	char arr[] = "abcdef";//注意數(shù)組里面放的是字符串！?。?
	printf("%d\n", sizeof(arr));
	//sizeof 內(nèi)部單獨(dú)放置數(shù)組名，即計(jì)算整個(gè)數(shù)組的大小
	//大小為 1(char類型)*7(元素個(gè)數(shù))=7
	printf("%d\n", sizeof(arr + 0));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，arr+0 表數(shù)組首元素地址
	//故 sizeof 計(jì)算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*arr));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，*arr 表對(duì)數(shù)組首元素地址解引用
	//即得到字符 'b' ,故大小為 1(char類型)
	printf("%d\n", sizeof(arr[1]));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，arr[1] 表數(shù)組第二個(gè)元素即字符 'b'
	//故大小為 1(char類型)
	printf("%d\n", sizeof(&arr));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&arr 表對(duì)整個(gè)數(shù)組取地址
	//故 sizeof 計(jì)算的地址(指針)大小為 4 or 8
	printf("%d\n", sizeof(&arr + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&arr+1 表取出整個(gè)數(shù)組地址并向后跳躍一個(gè)數(shù)組類型大小
	//即指向元素 '\0' 后面一塊數(shù)組類型大小的空間
	//故 sizeof 計(jì)算的地址(指針)大小為 4 or 8
	printf("%d\n", sizeof(&arr[0] + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，&arr[0]+1 表取出數(shù)組首元素地址并向后跳躍一個(gè) char 類型大小
	//即指向數(shù)組第二個(gè)元素
	//故 sizeof 計(jì)算的地址(指針)大小為 4 or 8
	printf("%d\n", strlen(arr));
	//strlen 不是 sizeof ，arr 表數(shù)組首元素地址，strlen 會(huì)以此為起始地址向后尋找 '\0'
	//因?yàn)榇藬?shù)組包含 '\0' ，故 strlen 的返回值為 6
	printf("%d\n", strlen(arr + 0));
	//arr+0 表數(shù)組首元素地址，strlen 會(huì)以此地址為起始地址向后尋找 '\0'
	//因?yàn)榇藬?shù)組包含 '\0' ，故 strlen 的返回值為 6
	printf("%d\n", strlen(*arr));
	//*arr 表對(duì)數(shù)組首元素地址解引用，得到字符 'a' ，其 ASCLL 碼值為 97
	//故 strlen 會(huì)以此地址為起始地址向后尋找 '\0'
	//但個(gè)人理解認(rèn)位： 97 是一個(gè)沒有初始化的指針(地址)，即野指針
	//故這里會(huì)報(bào)錯(cuò)
	printf("%d\n", strlen(arr[1]));
	//arr[1] 表數(shù)組第二個(gè)元素，即字符 'b' ，其 ASCLL 碼值為 98
	//strlen 會(huì)以此地址會(huì)起始地址向后尋找 '\0'
	//但個(gè)人理解認(rèn)位：98 是一個(gè)沒有初始化的指針(地址)，即野指針
	//故這里會(huì)報(bào)錯(cuò)
	printf("%d\n", strlen(&arr));
	//&arr 表取出整個(gè)數(shù)組的地址，但觀察 strlen 函數(shù)的聲明可以發(fā)現(xiàn)
	//strlen 的函數(shù)參數(shù)是一個(gè) char* 類型的指針
	//即我們傳參傳進(jìn)去的是一個(gè)數(shù)組指針，當(dāng) strlen 接收的時(shí)候，會(huì)將其強(qiáng)轉(zhuǎn)為字符指針
	//故 strlen 會(huì)以數(shù)組首元素地址為起始地址，向后尋找 '\0'
	//因?yàn)閿?shù)組包含 '\0' ，故 strlen 的返回值為 6
	printf("%d\n", strlen(&arr + 1));
	//&arr+1 表取出整個(gè)數(shù)組的地址并向后跳躍一個(gè)數(shù)組類型大小
	//即指向 '\0' 后一塊數(shù)組類型的空間
	//strlen 會(huì)以此地址為起始地址向后尋找 '\0'
	//但我們無法確定 '\0' 的具體位置，所以 strlen 會(huì)返回一個(gè)隨機(jī)值
	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]+1 表取出數(shù)組首元素地址并向后跳躍一個(gè) char 類型的大小
	//即指向了數(shù)組第二個(gè)元素的地址
	//strlen 會(huì)以此地址作為起始地址向后尋找 '\0'
	//故 strlen 的返回值為 5
	return 0;
}

#include <stdio.h>
int main()
{
	char* p = "abcdef";//p 變量存放的是字符串常量的首元素地址
	printf("%d\n", sizeof(p));
	//sizeof 計(jì)算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(p + 1));
	//p+1 表字符串常量的第二個(gè)元素的地址
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*p));
	//*p 表對(duì)字符串常量首元素地址解引用。得到字符 'a'
	//故計(jì)算的大小為 1(char類型)
	printf("%d\n", sizeof(p[0]));
	//p[0] 可改寫成 *(p+0) ,表對(duì)字符串常量首元素地址解引用，得到字符 'a'
	//即計(jì)算的大小為 1(char類型)
	printf("%d\n", sizeof(&p));
	//&p 表對(duì) char* 類型指針取地址
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&p + 1));
	//&p+1 表對(duì) char* 類型指針變量 p 取地址并向后跳躍一個(gè) char 類型的大小
	//指向的空間是未知的
	//但 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&p[0] + 1));
	//&p[0]+1 可改寫成 &(*(p+0)）+1 ,表取出字符串常量的首元素地址并向后跳躍一個(gè) char 類型的大小
	//即指向了字符 'b'
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", strlen(p));
	//strlen 不是 sizeof ，p表字符串首元素地址
	//strlen 以此地址為起始地址，向后尋找 '\0'
	//故 strlen 的返回值為 6
	printf("%d\n", strlen(p + 1));
	//p+1 表字符串常量的第二個(gè)元素的地址，strlen 會(huì)以此為地址向后尋找 '\0'
	//故 strlen 的返回值為 5
	printf("%d\n", strlen(*p));
	//*p 表字符串常量首元素，即字符 'a',strlen 會(huì)以此為地址向后尋找 '\0'
	//但個(gè)人理解人為：'a' 的 ASCLL 碼值為 97 ，但 97 是一個(gè)沒有被初始化的指針(地址)，即野指針
	//故這里會(huì)報(bào)錯(cuò)
	printf("%d\n", strlen(p[0]));
	//p[0] 可改寫成 *(p+0) ，表字符串常量首元素，即字符 'a'，其 ASCLL 碼值為 97
	//strlen 會(huì)以此地址為起始地址向后尋找 '\0'
	//但個(gè)人理解認(rèn)位：97 是一個(gè)沒有被初始化的指針(地址)，即野指針
	//故這里會(huì)報(bào)錯(cuò)
	printf("%d\n", strlen(&p));
	//&p 表取出 char* 類型指針變量的地址，strlen 以此地址為起始地址向后尋找 '\0'
	//但我們無法確定 '\0' 的位置
	//故 strlen 會(huì)返回一個(gè)隨機(jī)值
	printf("%d\n", strlen(&p + 1));
	//&p+1 表取出 char* 類型指針變量的地址并向后跳躍一個(gè) char 類型的大小，strlen 以此地址為起始地址向后尋找 '\0'
	//但我們無法確定 '\0'的位置，故 strlen 的返回值會(huì)返回一個(gè)隨機(jī)值
	printf("%d\n", strlen(&p[0] + 1));
	//*p{0}+1 可改寫為 &(*(p+0))+1 ，表取出字符串常量首元素地址并向后跳躍一個(gè) char 類型的大小
	//即指向了字符串常量的第二個(gè)元素的地址，strlen 會(huì)以此地址為起始地址向后尋找 '\0'
	//故 strlen 的返回值為 5
	return 0;
}

#include <stdio.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	//sizeof 內(nèi)部放置的是數(shù)組名，故計(jì)算整個(gè)數(shù)組的大小
	//即大小為 4(int類型)*12(元素個(gè)數(shù))=48
	printf("%d\n", sizeof(a[0][0]));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，a[0][p] 表數(shù)組首元素
	//故 sizeof 的計(jì)算值為 4(int類型)
	printf("%d\n", sizeof(a[0]));
	//sizeof 內(nèi)部放置的看似不是單獨(dú)的數(shù)組名，但 a[0] 表數(shù)組的第一個(gè)元素
	//此元素也是一個(gè)數(shù)組
	//故 sizeof 計(jì)算的大小為 4(int類型)*4(元素個(gè)數(shù))=16
	printf("%d\n", sizeof(a[0] + 1));
	//sizeof 內(nèi)部放置的不是單獨(dú)的數(shù)組名，a[0] 表二維數(shù)組的第一個(gè)元素，即拿到了一個(gè)數(shù)組
	//a[0]+1 表二維數(shù)組的第一個(gè)數(shù)組元素的地址并向后跳躍一個(gè) int 類型的大小
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*(a[0] + 1)));
	//*(a[0]+1) 表對(duì)二維數(shù)組的第一個(gè)數(shù)組元素的地址并向后跳躍一個(gè) int 類型的大小的解引用
	//即找到了二維數(shù)組中的某一個(gè)元素
	//故 sizeof 計(jì)算的大小為 4(int類型)
	printf("%d\n", sizeof(a + 1));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，a+1 表二維數(shù)組的首元素地址并向后跳躍一個(gè)一維數(shù)組類型的大小
	//即指向了二維數(shù)組的第二個(gè)數(shù)組元素的地址
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*(a + 1)));
	//*(a+1) 表對(duì)二維數(shù)組的首元素地址并向后跳躍一個(gè)一維數(shù)組類型的大小的解引用
	//即得到了二維數(shù)組的第二個(gè)元素
	//此元素為一個(gè)一維數(shù)組，故 sizeof 計(jì)算的大小為 4(int類型)*4(元素個(gè)數(shù))=16
	printf("%d\n", sizeof(&a[0] + 1));
	//&a[0]+1 表二維數(shù)組的首元素取地址并向后跳躍一個(gè)一維數(shù)組的類型大小
	//指向了二維數(shù)組的第二個(gè)元素
	//故 sizeof 計(jì)算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*(&a[0] + 1)));
	//*(&a[0]+1) 表對(duì)二維數(shù)組的首元素取地址并向后跳躍一個(gè)一維數(shù)組的類型大小的解引用
	//即得到了二維數(shù)組的第二個(gè)元素
	//此元素是一個(gè)一維數(shù)組，故 sizeof 計(jì)算的大小的 4(int類型)*4(元素個(gè)數(shù))=16
	printf("%d\n", sizeof(*a));
	//sizeof 內(nèi)部沒有單獨(dú)放置數(shù)組名，*a 表對(duì)二維數(shù)組首元素地址解引用
	//得到一個(gè)一維數(shù)組
	//故 sizeof 計(jì)算的大小為 4(int類型)*4(元素個(gè)數(shù))=16
	printf("%d\n", sizeof(a[3]));
	//a[3] 表二維數(shù)組的第三個(gè)元素
	//需要說明的是，sizeof 只對(duì)類型感興趣
	//也就是說，二維數(shù)組雖然不存在第三個(gè)元素，但它的類型依舊是二維數(shù)組
	//故 sizeof 計(jì)算的是 4(int類型)*4(元素個(gè)數(shù))=16
	return 0;
}