#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 內部單獨放置數組名，計算整個數組的大小，結果為 4(int類型)*4(元素個數)=16
	printf("%d\n", sizeof(a + 0));
	//sizeof 內部沒有單獨放置數組名，此時數組名表首元素地址，a+0 依然表示首元素地址
	//故 sizeof 計算一個地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*a));
	//sizeof 內部沒有單獨放置數組名，此時數組名表首元素地址，*a 表對該地址解引用
	//即可得到 a 數組的第一個元素，大小為 4(int類型)
	printf("%d\n", sizeof(a + 1));
	//sizeof 內部沒有單獨放置數組名，此時數組名表首元素地址，a+1 表第二個元素地址
	//故 sizeof 計算一個地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(a[1]));
	//sizeof 內部沒有單獨放置數組名，a[1] 表數組的第二個元素，此寫法可轉置為 *(a+1)
	//即計算的結果是第二個元素的類型大小，即 4(int類型)
	printf("%d\n", sizeof(&a));
	//sizeof 內部沒有單獨放置數組名，而是放置了 &a ，表取出整個數組的地址
	//故 sizeof 計算一個地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*&a));
	//sizeof 內部雖然看似沒有單獨放置數組名，但是通過 &a 取出整個數組地址
	//然后通過 * 找到整個地址，與 sizeof(a) 沒有差別
	//故這里的 sizeof 計算的也是整個數組的大小，即 4(int類型)*4(元素個數)=16
	printf("%d\n", sizeof(&a + 1));
	//sizeof 內部沒有單獨放置數組名，&a+1 表取出整個數組的地址，并向后跳躍一個數組類型的大小
	//即此時的地址是指向元素 4 的后面一塊 int 類型的內存空間
	//故 sizeof 計算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&a[0]));
	//sizeof 內部沒有單獨放置數組名，&a[0] 表取出數組第一個元素的地址
	//故 sizeof 計算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&a[0] + 1));
	//sizeof 內部沒有單獨放置數組名，&a[0]+1 表取出數組第一個元素地址并向后跳躍一個 int 類型的大小
	//故 sizeof 計算的是地址(指針)的大小為 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 內部單獨放置數組名，故計算的是整個數組的大小
	//即大小為 1(char類型)*6(元素個數)=6
	printf("%d\n", sizeof(arr + 0));
	//sizeof 內部沒有單獨放置數組名，arr 表數組首元素地址，arr+0 亦表示首元素地址
	//故 sizeof 計算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*arr));
	//sizeof 內部沒有單獨放置數組名，arr 表數組首元素地址，*arr 表對該地址解引用
	//便得到數組第一個元素 'a' ，故大小為 1(char類型)
	printf("%d\n", sizeof(arr[1]));
	//sizeof 內部沒有單獨放置數組名，arr[1] 表數組第二個元素，即 'b'
	//故大小為 1(char類型)
	printf("%d\n", sizeof(&arr));
	//sizeof 內部沒有單獨放置數組名，&arr 表取出整個數組的地址
	//故 sizeof 計算的地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&arr + 1));
	//sizeof 內部沒有單獨放置數組名，&arr+1 表取出整個數組的地址并向后跳躍一個數組類型的大小
	//即指向元素 'f' 后一個 char 類型的空間
	//故 sizeof 計算的是地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(&arr[0] + 1));
	//sizeof 內部沒有單獨放置數組名，&arr[0]+1 表取出數組一個元素的地址并向后跳躍一個 char 類型的大小
	//故 sizeof 計算的地址(指針)的大小為 4 or 8
	printf("%d\n", strlen(arr));
	//strlen 不是 sizeof ，故 arr 表數組首元素地址，strlen 會以此地址開始向后尋找 '\0'
	//但此數組并不包含 '\0' ，故 strlen 的返回值為隨機值
	printf("%d\n", strlen(arr + 0));
	//strlen 不是 sizeof ，arr+0 表首元素地址，strlen 的返回值也是一個隨機值
	printf("%d\n", strlen(*arr));
	//strlen 不是 sizeof ，*arr 表對數組首元素地址解引用，得到字符 'a' ，其 ASCLL 碼值為 97
	//strlen 會以 97 為起始地址向后尋找 '\0' 
	//但個人理解認為：97 是一個沒有初始化的指針(地址)，即野指針
	//故這里會報錯
	printf("%d\n", strlen(arr[1]));
	//arr[1] 表數組的第二個元素 'b' ，其 ASCLL 碼值為 98
	//strlen 會以 98 為起始地址向后尋找 '\0'
	//但個人理解認位：98 是一個沒有初始化的指針(地址)，即野指針
	//故這里依然會報錯
	printf("%d\n", strlen(&arr));
	//&arr 表取出整個數組的地址，strlen 會以此作為起始地址向后尋找 '\0'
	//這里需要注意，在 strlen 的函數聲明當中，參數是一個 char* 類型的指針
	//也就是我們雖然傳參時傳了一個數組指針，但是 strlen 接收時會自動強轉為 char* 類型指針
	//故數組并不包含 '\0' ，strlen 的返回值是一個隨機值
	printf("%d\n", strlen(&arr + 1));
	//&arr+1 表取出整個數組的地址并向后跳躍一個數組類型的大小
	//即指向了元素 'f' 的后一塊 char 類型的空間
	//strlen 會以此地址作為起始地址向后尋找 '\0'
	//但因我們無法確定 '\0' 的位置，所以 strlen 的返回值是一個隨機值
	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]+1 表取出數組首元素地址并向后跳躍一個 char 類型的大小
	//即指向了元素 'b' ,strlen 會以此地址作為起始地址向后尋找 '\0'
	//但數組中并不包含 '\0' ，故 strlen 的返回值是一個隨機值
	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";//注意數組里面放的是字符串！！！
	printf("%d\n", sizeof(arr));
	//sizeof 內部單獨放置數組名，即計算整個數組的大小
	//大小為 1(char類型)*7(元素個數)=7
	printf("%d\n", sizeof(arr + 0));
	//sizeof 內部沒有單獨放置數組名，arr+0 表數組首元素地址
	//故 sizeof 計算地址(指針)的大小為 4 or 8
	printf("%d\n", sizeof(*arr));
	//sizeof 內部沒有單獨放置數組名，*arr 表對數組首元素地址解引用
	//即得到字符 'b' ,故大小為 1(char類型)
	printf("%d\n", sizeof(arr[1]));
	//sizeof 內部沒有單獨放置數組名，arr[1] 表數組第二個元素即字符 'b'
	//故大小為 1(char類型)
	printf("%d\n", sizeof(&arr));
	//sizeof 內部沒有單獨放置數組名，&arr 表對整個數組取地址
	//故 sizeof 計算的地址(指針)大小為 4 or 8
	printf("%d\n", sizeof(&arr + 1));
	//sizeof 內部沒有單獨放置數組名，&arr+1 表取出整個數組地址并向后跳躍一個數組類型大小
	//即指向元素 '\0' 后面一塊數組類型大小的空間
	//故 sizeof 計算的地址(指針)大小為 4 or 8
	printf("%d\n", sizeof(&arr[0] + 1));
	//sizeof 內部沒有單獨放置數組名，&arr[0]+1 表取出數組首元素地址并向后跳躍一個 char 類型大小
	//即指向數組第二個元素
	//故 sizeof 計算的地址(指針)大小為 4 or 8
	printf("%d\n", strlen(arr));
	//strlen 不是 sizeof ，arr 表數組首元素地址，strlen 會以此為起始地址向后尋找 '\0'
	//因為此數組包含 '\0' ，故 strlen 的返回值為 6
	printf("%d\n", strlen(arr + 0));
	//arr+0 表數組首元素地址，strlen 會以此地址為起始地址向后尋找 '\0'
	//因為此數組包含 '\0' ，故 strlen 的返回值為 6
	printf("%d\n", strlen(*arr));
	//*arr 表對數組首元素地址解引用，得到字符 'a' ，其 ASCLL 碼值為 97
	//故 strlen 會以此地址為起始地址向后尋找 '\0'
	//但個人理解認位： 97 是一個沒有初始化的指針(地址)，即野指針
	//故這里會報錯
	printf("%d\n", strlen(arr[1]));
	//arr[1] 表數組第二個元素，即字符 'b' ，其 ASCLL 碼值為 98
	//strlen 會以此地址會起始地址向后尋找 '\0'
	//但個人理解認位：98 是一個沒有初始化的指針(地址)，即野指針
	//故這里會報錯
	printf("%d\n", strlen(&arr));
	//&arr 表取出整個數組的地址，但觀察 strlen 函數的聲明可以發現
	//strlen 的函數參數是一個 char* 類型的指針
	//即我們傳參傳進去的是一個數組指針，當 strlen 接收的時候，會將其強轉為字符指針
	//故 strlen 會以數組首元素地址為起始地址，向后尋找 '\0'
	//因為數組包含 '\0' ，故 strlen 的返回值為 6
	printf("%d\n", strlen(&arr + 1));
	//&arr+1 表取出整個數組的地址并向后跳躍一個數組類型大小
	//即指向 '\0' 后一塊數組類型的空間
	//strlen 會以此地址為起始地址向后尋找 '\0'
	//但我們無法確定 '\0' 的具體位置，所以 strlen 會返回一個隨機值
	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]+1 表取出數組首元素地址并向后跳躍一個 char 類型的大小
	//即指向了數組第二個元素的地址
	//strlen 會以此地址作為起始地址向后尋找 '\0'
	//故 strlen 的返回值為 5
	return 0;
}

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

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