系列文章目錄
文章目錄
- 系列文章目錄
- 前言
- 一、字符指標
- 1.字符指標的定義
- 2.字符指標的實作
- 二、指標陣列
- 1.指標陣列的定義
- 2.指標陣列的實作
- 三、陣列指標
- 1.陣列指標的定義
- 2.區分&陣列名和陣列名
- 2.陣列指標的使用
- 3.區分陣列指標和指標陣列
- 四、陣列傳參、指標傳參
- 1.陣列傳參的定義
- 2.一維陣列和二維陣列
- 3.指標傳參的定義
- 4.一維指標和二維指標
- 五、函式指標
- 1.函式指標的定義
- 2.函式指標的使用
- 五、函式指標陣列
- 1.函式指標陣列的定義
- 2.函式指標陣列的使用
- 3.函式指標陣列的應用之轉移表(計算器)
- 六、回呼函式
- 1.回呼函式的定義
- 2.回呼函式之qsort的用法
- 3.回呼函式之qsort的模擬實作
- 總結
前言
1. 指標就是個變數，用來存放地址，地址唯一標識一塊記憶體空間，
2. 指標的大小是固定的4/8個位元組（32位平臺/64位平臺），
3. 指標是有型別，指標的型別決定了指標的±整數的步長，指標解參考操作的時候的權限，
4. 指標的運算，
一、字符指標
1.字符指標的定義
存放字符的指標
2.字符指標的實作
代碼如下：
int main()
{
char ch = 'a'; //字符指標
char* pa = &ch;
char* pstr = "hello bit.";
printf("%c\n", *pb);
printf("%s\n", pb);
}
代碼 char* pstr = “hello bit.”; 特別容易讓同學以為是把字串 hello bit 放到字符指標 pstr 里了，但是/本質是把字串 hello bit. 首字符的地址放到了pstr中，
經典例題：
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
char *str3 = "hello bit.";
char *str4 = "hello bit.";
if (str1 == str2) //str1與str2是兩塊完全不同的空間
{
printf("str1 and str2 are same\n");
}
else
{
printf("str1 and str2 are not same\n");
}
if (str3 == str4) //str3與str4指向的常量字串，存放的是hello bit首字符的地址，字串在記憶體中是連續存放的，所以可以找到字串hello bit
{
printf("str3 and str4 are same\n");
}
else
{
printf("str3 and str4 are not same\n");
}
return 0;
}
這里str3和str4指向的是一個同一個常量字串，C/C++會把常量字串存盤到單獨的一個記憶體區域，當幾個指標，指向同一個字串的時候，他們實際會指向同一塊記憶體，但是用相同的常量字串去初始化不同的陣列的時候就會開辟出不同的記憶體塊，所以str1和str2不同，str3和str4不同，
二、指標陣列
1.指標陣列的定義
指標陣列是一個存放指標的陣列
2.指標陣列的實作
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main() //指標陣列--陣列--存放指標的陣列
{
char* arr1[10] = { 0 };
//arr1陣列有10個元素，每個元素是char*型別
int* arr2[10] = { 0 };
//arr2陣列有10個元素，每個元素是int*型別
char** arr3[10] = { 0 };
//arr3陣列有10個元素，每個元素是char**型別
return 0;
}
三、陣列指標
1.陣列指標的定義
能夠指向陣列的指標
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main() //陣列指標--指標--指向陣列的指標
{
int arr1[10] = { 0 };
int(*pa)[10] = &arr1;
//&arr取出的是整個陣列的地址，pa與*結合是指標，指向的陣列arr有10個元素，每個元素型別是int型別
int* pb[10] = { 0 };
//這里是指標陣列，pa陣列中有10個元素，每個元素型別是int* 型別
char ch[5] = { 0 };
char(*p3)[5] = &ch;
2.區分&陣列名和陣列名
&arr 表示的是陣列的地址，而不是陣列首元素的地址，（細細體會一下）陣列的地址+1，跳過整個陣列的大小，所以 &arr+1 相對于 &arr 的差值是40，
代碼如下：
int main()
{
int arr2[10] = { 1, 2, 3, 4, 5 };
int* pc = arr2;
int(*pd)[10] = &arr2;
printf("%p\n", pc); //pc指向的是首元素的地址，pc+1是跳過一個整形
printf("%p\n", pc + 1);
printf("%p\n", pd); // pb指向的是一個的陣列，pb+1是跳過一個整形陣列
printf("%p\n", pd + 1);
}
2.陣列指標的使用
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void print1(int arr2[3][5], int x, int y) //普通的二位陣列列印，陣列傳參，陣列接收
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", arr2[i][j]);
}
printf("\n");
}
}
void print2(int(*pd)[5], int x, int y) //用陣列指標來接收一維陣列
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", *((*pd + i) + j)); //(*pd+i)是找到第i行的地址，*((*pd+i)+j)是找到第i行第j列的元素
}
printf("\n");
}
}
int main() //陣列指標的使用->指向陣列的指標
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* pa = &arr;
int(*pb)[10] = &arr;
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", *(pa + i));
printf("%d ",(*pb)[i]); //*pa<==>arr
printf("%d ", *(*pb + i));
}
printf("\n");
int arr2[3][5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 3, 4, 5, 6, 7 } };
//二維陣列傳參，陣列名也是首元素地址，二位陣列的首元素是第一行
//傳過去的是第一行的地址->一維陣列的地址
print1(arr2, 3, 5);
print2(arr2, 3, 5);
return 0;
}
3.區分陣列指標和指標陣列
代碼如下：
int arr4[5];
int* arr5[10];
int(*pe)[10];
int(*pf[10])[5];
1.整形陣列，
2.指標陣列，arr5里面有10個元素，每個元素型別是int*，
3.陣列指標，pe指標指向的陣列里面有10個元素，每個元素 型別是int型別，
4.int(*)[5] ,存放陣列指標的陣列,pf陣列中有10個元素，每個元素型別是陣列指標，陣列指標有5個元素，元素型別是int，
四、陣列傳參、指標傳參
1.陣列傳參的定義
將陣列或陣列地址作為引數傳遞過去，
2.一維陣列和二維陣列
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
//一維陣列傳參
void test1(int arr1[])
{
}
void test1(int arr1[10])
{
}
void test1(int* arr1)
{
}
void test2(int *arr2[20])
{
}
void test2(int **arr2) //指標陣列傳參，傳參的是首元素地址，首元素地址型別是int*,所以用int** 來接收
{
}
//二維陣列傳參
void test3(int arr[3][5])
{
}
void test3(int arr3[][]) //錯誤的寫法->,行可以不寫,列不能不寫
{
}
void test3(int arr3[][5])
{
}
void test3(int* arr3) //錯誤的寫法，arr3是一個二維陣列，不能用整形指標來接收
{
}
void test3(int* arr3[5]) //錯誤的寫法，arr3是一個二維陣列，不能一個指標陣列來接收
{
}
void test3(int(*arr3)[5]) //arr3是一個指標，指向的arr3有個元素，每個元素型別是int型別
{
}
void test3(int** arr3) //錯誤的寫法，二級指標是用來接收一級指標的地址
{
}
int main()
{
//一維陣列傳參
int arr1[10] = { 0 };
int* arr2[20] = { 0 };
test1(arr1);
test2(arr2);
//二維陣列傳參
int arr3[3][5] = { 0 };
test3(arr3);
return 0;
}
3.指標傳參的定義
將指標的地址或二級指標傳遞過去
4.一維指標和二維指標
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void print(int* pa, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(pa + i));
}
printf("\n");
}
void test1(int** pb)
{
}
void test2(int** pc)
{
}
int main()
{
int arr1[] = { 1, 2, 4, 5, 6, 7, 8, 9, 10 };
int* pa = &arr1;
int sz = sizeof(arr1) / sizeof(arr1[0]);
//一級指標pa,傳給函式
print(pa, sz);
//二級指標傳參,二級指標來接收
int i = 0;
int* pb = &i;
int** pc = &pb;
test1(&pb); //傳一級指標的地址
test2(pc); //傳二級指標pc
return 0;
}
五、函式指標
1.函式指標的定義
存放函式的地址
2.函式指標的使用
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void test1(int* pa)
{
}
void test2(int(*pc)[5])
{
}
int add(int x, int y)
{
return x + y;
}
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str)
{
str++;
count++;
}
return count;
}
int main()
{
int arr1[10]; //一維陣列
int* pa = arr1; //首元素的地址
int(*pb)[10] = &arr1; //整個陣列的地址
test1(arr1);
int arr2[3][5];
int(*pc)[5] = arr2; //首元素的地址，二維陣列首元素的地址代表第一行的地址，所以用陣列指標接收
int(*pd)[3][5] = &arr2;
test2(arr2);
//整形指標---->存放整形的地址
//陣列指標---->存放陣列的地址
//函式指標---->存放函式的地址
int a = 10;
int* pe = &a;
char arr3[10] = { 0 };
char(*pf)[10] = &arr3;
printf("%p\n", &add);
printf("%p\n", add); //&函式名和函式名都是函式的地址
int(*pg)(int, int) = &add; //pg就是函式指標
int(*ph)(int, int) = add; //ph和pg表達的意思一樣
//函式指標的呼叫
int sum = (*pg)(2, 3); //== int usm=add(2,3);
int ret = (pg)(2, 3);
printf("%d\n", ret);
printf("%d\n", sum);
int(*str)(const char*) = &my_strlen;
int len = (*str)("bit education");
printf("%d\n", len);
}
1.型別在()里面就是強制型別轉換–>把0強制型別轉換為函式指標型別，然后解參考呼叫0地址處的函式，該函式回傳值為void，引數為無引數，
2.這是一個函式宣告，宣告的函式是signal,signal函式有兩個引數，第一個引數型別是int,第二個引數型別是函式指標，該函式的回傳值是空，引數是int ，signal函式的回傳型別是一個函式指標，該函式指標指向的函式引數是int，回傳型別是void，
五、函式指標陣列
1.函式指標陣列的定義
存放函式指標的陣列
2.函式指標陣列的使用
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int main() //函式指標陣列
{
int a = 10;
int b = 20;
int* arr[] = { &a, &b };
//函式指標->存放函式的地址
int(*pf1)(int, int) = Add;
int(*pf2)(int, int) = Sub;
//函式指標陣列->存放函式指標的陣列
int(*pfarr[2])(int, int) = { Add, Sub };
return 0;
}
3.函式指標陣列的應用之轉移表(計算器)
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void menu()
{
printf("*****************************\n");
printf("*****1.ADD 2.Sub ****\n");
printf("*****3.Mul 4.Div ****\n");
printf("***** 0.Exit ****\n");
printf("*****************************\n");
}
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x*y;
}
int Div(int x, int y)
{
return x / y;
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
int(*pfarr[])(int, int) = { 0, Add, Sub, Mul, Div }; //函式指標陣列的應用->轉移表,把4個函式的地址存放到函式指標陣列里面
do
{
menu();
printf("請輸入你的選擇:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出程式!\n");
break;
}
else if (input > 0 && input <= 4)
{
printf("請輸入兩個運算元:");
scanf("%d%d", &x, &y);
ret = pfarr[input](x, y);
printf("結果是:%d\n", ret);
}
else
{
printf("你的選擇錯誤，請重新選擇!\n");
}
} while (input);
return 0;
}
六、回呼函式
1.回呼函式的定義
回呼函式就是一個通過函式指標呼叫的函式，如果你把函式的指標（地址）作為引數傳遞給另一個函式，當這個指標被用來呼叫其所指向的函式時，我們就說這是回呼函式，回呼函式不是由該函式的實作方直接呼叫，而是在特定的事件或條件發生時由另外的一方呼叫的，用于對該事件或條件進行回應，
2.回呼函式之qsort的用法
1.void* base 待排序的資料的起始地址
2.size_t num 待排序的資料的元素個數
3.size_t width 待排序的資料的大小，單位是位元組
4.函式 比較兩個元素的地址
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
//冒泡排序只對整形排序
void Bubble_Sort(int arr[], int sz)
{
int i = 0;
int j = 0;
for (i = 0; i < sz-1; i++) //趟數
{
for (j = 0; j < sz - i - 1;j++) //次數
{
if (arr[j]>arr[j + 1])
{
int tmp = 0;
tmp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = tmp;
}
}
}
}
void qsort(void *base,
size_t num,
size_t width,
int(__cdecl *compare)(const void *elem1, const void *elem2)
);
//void* base 待排序的資料的起始地址
//size_t num 待排序的資料的元素個數
//size_t width 待排序的資料的大小，單位是位元組
//函式 比較兩個元素的地址
struct stu
{
char name[20];
int age;
};
//e1和e2是要比較元素的兩個地址
int cmp_int(const void* e1, const void* e2) //按照整形來排序
{
return(*(int*)e1 - *(int*)e2);
}
int cmp_by_age(const void* e1, const void* e2) //按照結構體中年齡來排序
{
return (((struct stu*)e1)->age - ((struct stu*)e2)->age);
}
int cmp_by_name(const void* e1, const void* e2) //按照結構體中名字來排序
{
return (strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name));
}
int main()
{
//void*的指標變數，可以接收任意型別的地址
//因為void*的指標，沒有具體型別，所以不能進行解參考操作，不能++/--
int a = 10;
int* p = &a;
int arr[] = { 1, 4, 5, 6, 3, 8, 9, 10, 2 };
int sz = sizeof(arr) / sizeof(arr[0]);
Bubble_Sort(arr, sz);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
//qsort實作對整形的排序
qsort(arr, sz, sizeof(arr[0]), cmp_int); //陣列名，陣列大小，資料占多少位元組，比較函式
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
struct stu Stu[] = { { "zhangsan", 15 }, { "lisi", 12 }, { "wangwu", 18 }, { "wanger", 14 } };
int num = sizeof(Stu) / sizeof(Stu[0]);
qsort(Stu, num, sizeof(Stu[0]), cmp_by_age); //按年齡來排序
for (i = 0; i < num; i++)
{
printf("%d->%s ", Stu[i].age,Stu[i].name);
}
printf("\n");
qsort(Stu, num, sizeof(Stu[0]), cmp_by_name); //按照名字來排序,相當于比較字串
for (i = 0; i < num; i++)
{
printf("%s->%d ", Stu[i].name, Stu[i].age);
}
printf("\n");
return 0;
}
3.回呼函式之qsort的模擬實作
代碼如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int cmp_int(const void* e1, const void* e2)
{
return (*(char*)e1 - *(char*)e2);
}
void _swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp =*buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void Bubble_Sort(void* base, int num, int width, int(*cmp)(const void* e1, const void* e2))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (cmp((char*)base + j*width, (char*)base + (j + 1)*width)>0)
{
_swap((char*)base + j*width, (char*)base + (j + 1)*width, width);
}
}
}
}
int main()
{
int i = 0;
int arr[] = { 3, 2, 5, 7, 4 };
int sz = sizeof(arr) / sizeof(arr[0]);
Bubble_Sort(arr, sz, sizeof(arr[0]), cmp_int);
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
總結
以上就是今天要講的指標進階的大部分內容，本文詳細的介紹了C語言中指標的難點和重點，而指標提供了大量便利我們快速便捷地處理資料，希望大家掌握，另外，如果上述有任何問題，請懂哥指教，不過沒關系，主要是自己能堅持，更希望有一起學習的同學可以幫我指正，但是如果可以請溫柔一點跟我講，愛與和平是永遠的主題，愛各位了，
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/271612.html
標籤：其他
上一篇：C語言順序表實作動態通訊錄，并將通訊錄檔案儲存在二進制檔案中（手把手教學除錯，小白入）
下一篇：C語言：檔案操作集合，干貨滿滿！