1、認識指針#include <stdio.h>
//基本數據類型作為函數參數傳遞是值傳遞
//void moveFront(int x ,int y)
//{
// x = x + 2;
//}
void test()
{// 確定當前坐標int x = 20;int y = 150;printf("%p\n",&x);printf("%lu\n",&x);*((int *)(0x7fff5fbff76c)) = 22;printf("(%d,%d)\n",x,y);// moveFront(x, y);// printf("(%d,%d)\n",x,y);}//假設你想訪問指針所指向存儲空間，就必須使用訪問指針所指向的存儲空間的操作符
void moveFront(int *x ,int *y)
{
// x = x + 2;//此時是改變指針的指向，而不是訪問指針所指向的存儲空間*x = *x + 2;
}int main(int argc, const char * argv[]) {// 確定當前坐標int x = 20;int y = 150;printf("(%d,%d)\n",x,y);moveFront(&x, &y);printf("(%d,%d)\n",x,y);return 0;
}
2、指針的定義與初始化(重點掌握)
? ?內存中最小的存儲單元：字節。每個字節在內存中都有一個編號，這編號就是指針
?
? 指針：內存地址
? 有了指針你就有了打開這塊內存鑰匙，就能夠操作這一塊內存
?
? 指針變量：存放內存地址的變量
? 定義指針：指針所指向數據類型 ?* 指針變量名稱;
?在的定義變量時候，*是一個類型說明符，說明定義這個變量是一個指針變量
? 在不是定義的變量的時候。*是一個操作符。訪問(讀、寫)指針所指向的那塊存儲空
? ? 指針的初始化：
??
? ? 注意點：
? ? 1、僅僅有定義沒有初始化指針里面是一個垃圾值。這時候我們成為這個指針為野指針
? ? 2、假設操作一個野指針
? ? ? ?2.1 程序崩潰
? ? ? ?2.2 訪問不該你訪問存儲。操作潛在邏輯錯誤
? ? 3、不能夠使用整形常量賦值一個指針變量
? ? ? ?由于內存是操作系統分配我們的，不是我們隨便取的
? ? 4、什么類型的指針。僅僅指向什么類型的變量
? ? 5、多個指針能夠指向同一變量
? ? 6、指針的指向是能夠改變的
#include <stdio.h>//指針的定義
void test()
{int num = 10;// 定義一個指針變量int *p;p = #*p = 20;printf("num = %d\n",num);
}int main(int argc, const char * argv[]) {// 先定義在進行初始化int num = 10;
// 定義一個指針變量pint * p;// *p = # // p 還有進行初始。不可以訪問它所指向存儲空間p = #//p 指向 num*p = 20;// 定義指針變量的同一時候進行初始int num2 = 20;int *p2 = &num2;*p2 = 40;printf("%d,%d\n",num2,*p2);// 不可以使用整形常量賦值一個指針變量
// 由于內存是操作系統分配我們的，不是我們隨便取的// int *p3 = 100000;//此處是錯誤的
//
// *p3 = 10;p2 = #printf("%p\n",p2);char c = 'a';int *pc = &c;*pc = 10;printf("%p\n",p2);return 0;
}
3、多級指針
通過指針訪問變量稱為間接訪問。
因為指針變量直接指向變量，所以稱為“一級指針”。而
假設通過指向指針的指針變量來訪問變量則構成“二級指針”。
#include <stdio.h>void test()
{int num = 10;int *p = #// 定義一個指針來指向變量p// pp就是一個二級指針int **pp = &p;**pp = 30;printf("%d\n",num);int ***ppp = &pp;***ppp = 50;printf("%d\n",num);// 四級指針int ****pppp = &ppp;****pppp = 100;printf("%d\n",num);
}
void readFile(char **error)
{*error = "讀取錯誤";
}int main(int argc, const char * argv[]) {// char error[100];char *error;readFile(&error);printf("%s",error);return 0;
}4、指針為什么要區分類型
? ?1、變量的地址是變量所在占存儲空間的首地址
? ?2、指針變量只能夠存儲一個地址編號，假設沒有類型。當通過指針就不知道要訪問多少個字節的存儲空間
? ?3、指針區分類型是為了在通過指針訪問它所指向的存儲空間的時候，可以正確訪問
? ?4、假設通過一個char類型的指針操作一個int的變量。假設值的二進制數據超過1字節，那么就造成數據錯誤
? ?5、假設通過一個int 類型的指針操作一個char變量，那么你就會改動了你不該改動的內存，造成程序邏輯錯誤
#include <stdio.h>
/*全部指針類型都是占用八個字節的存儲空間*/
void testEveryPointerIs8B()
{printf("%lu\n",sizeof(int *));printf("%lu\n",sizeof(char *));printf("%lu\n",sizeof(double *));printf("%lu\n",sizeof(float *));printf("%lu\n",sizeof(float **));
}int main(int argc, const char * argv[]) {int num = 10;char *cp = #printf("%d\n",num);return 0;
}
5、指針運算概述
? ?指針變量：存放是內存字節的地址編號(無符號的整形數)
? ?指針：是運算受限的無符號的整形數
? ?運算運算：
? ?指針 + 整形數 === 指針變量中值 + sizeof(其所指向數據類型)
? ?指針 - 整數數 === 指針變量中值 - sizeof(其所指向數據類型)
? ?pointer1 - pointer2 = (pointer1中值 - pointer2中值) / sizeof(其指向數據類型)?
? ?賦值運算：
? ? =
? ? += 必須是一個整形數
? ? -= 必須是一個整形數
? ?比較運算
? ?==
? ?!=?
? ?>
? ?<?
? ?>=
? ?<=
? ?自增自減
? ?p++; p = p + 1;
? ?++p; p = p + 1;
? ?--p;
? ?p--;
?
#include <stdio.h>//算術運算
void test()
{int a = 10;int *p = &a;// 指針＋1p = p + 1;int nums[5] = {1,2,3,4,5};int * pointer1 = nums;int * pointer2 = &nums[4];size_t size = pointer2 - pointer1; printf("%lu\n",size); // pointer1 + pointer2;// pointer2 * pointer1;// pointer1 / pointer2;// pointer1 / 2;
}
//賦值運算
void test1()
{int a = 10;// int *p = &a;int nums[] = {1,2,3,4,5};int *p = nums;int *p2 = nums;p += 2;p = p + 2;p -= 1;printf("%d\n",*p);
}//關系運算
int main(int argc, const char * argv[]) {int nums[] = {1,2,3,4,5};int *p = nums;p++;int result = nums == p;result = p > nums;p--;result = p < nums; result = p >= nums;result = p <= nums; printf("%d\n",result); return 0;
}?數組像一個指針：訪問數組中元素，使用數組與使用指向這個數組的指針是等價
?
?nums[1] ==== p[1]
?nums+1 ?==== p + 1;
?
?nums[1] 的本質 *(nums + 1)
?指針 + 整數 ===== ?指針中的值 + sizeof(所指向的數據類型) * 整數
// ? ?int nums[] = {1,2,3,4,5};
//
// ? ?int *p = nums;
double nums[] = {1.0,2.0,3,4,5};
double * p = nums;
// ? ?printf("%d,%d,%d,%d,%d,%d\n",nums[1],p[1],*(nums + 1),*(p + 1),*(++p),。
);
printf("%p\n",nums);
printf("%p\n",nums+2);
printf("%p\n",p);
printf("%p\n",p+2);
? 數組不是一個指針
? ?1、sizeof(array) != sizeof(pointer):當一個數組賦值一個指針變量的時候，那么數組中有些信息就丟失了，比方數組長度，這樣的現象指針信息遺失
? ?2、指針的指向是能夠改變的，數組的指向是不能夠改變
? ?3、array == &array 數組名就是數組地址，pointer != &pointer : 指針所指向地址不是指針本身地址
#include <stdio.h>
int main(int argc, const char * argv[]) {int nums[] = {1,2,3,4,5};int *p = nums;p = nums;
// nums = nums + 1; printf("%lu,%lu\n",sizeof(nums),sizeof(p)); printf("%p\n",nums);printf("%p\n",&nums); printf("%p\n",p);printf("%p\n",&p); return 0;
}7、指針與二維數組
指針數組與二維數組指針變量的差別
應該注意指針數組和二維數組指針變量的差別。這兩者盡管都可用來表示二維數組，可是其表示方法和意義是
不同的。
二維數組指針變量是單個的變量，其一般形式中"(*指針變量名)"兩邊的括號不可少。而指針數組類型表示的
是多個指針(一組有序指針)在一般形式中"*指針數組名"兩邊不能有括號。
比如：
int (*p)[3];
表示一個指向二維數組的指針變量。該二維數組的列數為3或分解為一維數組的長度為3。
int *p[3]
表示p是一個指針數組，有三個下標變量p[0]。p[1]，p[2]均為指針變量。
#include <stdio.h>void test()
{int nums[3][2] = {{1,2},{3,4},{5,6}}; int *p = nums[0]; printf("%p\n",p);printf("%p\n",nums); for (int i = 1; i < 6; i++) {printf("%d ",*(p + i));}}
/*定義指針數組的格式：數據類型 * 指針變量名稱[指針個數]*/
void test2()
{int nums[3][2] = {{1,2},{3,4},{5,6}};// int * p[2] = {nums[0],nums[1]};// p = nums;//// printf("%d\n",p[0][1]);int a = 10;int b = 20;int c = 30;int *p = &a;// *p === p[1]; 沒有這么寫的int *ps[3] = {&a,&b,&c};printf("%d,%d,%d",*ps[0],*ps[1],*ps[2]);}
/*定義一個指向一維數組的指針數據類型 (*指針名稱)[所指向的一維數組的元素個數]指針 + 整數 === 指針中的值 + 所指向數據類型的長度 * 整數*/int main(int argc, const char * argv[]) {int nums[3][2] = {{1,2},{3,4},{5,6}};int (*ps)[2];ps = nums;//能夠覺得ps 與 nums是等價的 int num = ps[0][1];printf("%d\n",num); printf("%p\n",nums);printf("%p\n",nums+1); printf("%p\n",ps);printf("%p\n",ps+1); for (int i =0 ; i < 3; i++) {for (int j = 0; j < 2 ; j++) {printf("%d ",ps[i][j]);}printf("\n");}// nums nums[0]// 同樣點：相應地址都是一樣的
// 不同點:指針類型是不同
// nums + 1 = nums + sizeof(nums[0])
// nums[0] + 1 = nums + sizeof(int)// sizeof(nums) 二維數組所用占用存儲空間字節數
// sizeof(nums) / sizeof(int) 二維數組中一共同擁有多少個int的數據int *p = nums[0];for (int i = 0; i < sizeof(nums) / sizeof(int); i++) {printf("%d ",p[i]);}return 0;
}
 (貪心) 思想 !思想!)
