目录
4.案例：用函数让用户自己输入一个数组，并且使用户可以提取第任意行列上的数值
3.案例：a个学生分别b门成绩，输入学生序号可输出学生全部成绩，用指针函数来实现
注：程序编译没问题，运行就崩溃，毫无提示，一般是野指针
一 指针
1 基本概念
取值运算符，把内存地址中的数据提取出来
*(&a)
| 指针变量 | 变量的指针/地址 |
| *p | p |
#include<stdio.h>
int main(){
int a = 10;
int *p;
p = &a;
printf("a= %d\n",a);
printf("a(address)= 0x%p\n",&a);
printf("a = %d\n",*(&a));//取值运算符，把内存地址中的数据提取出来
printf("p(address)= 0x%p\n",p);
printf("p= %d\n",*p);
return 0;
}输出：
a= 10
a(address)= 0x000000000061FE14
a = 10
p(address)= 0x000000000061FE14
p= 10
2 案例演示：交换两个变量的值
一般交换 a 和 b 两个值的时候会采用一个中间量 tmp，但是调用函数形式是无法完成这个操作的：
错误代码：
函数中的 a 和 b 虽然接收了 main 中 a 和 b 的值，但是本质上不是相同的变量，内存地址不同
#include<stdio.h>
void change(int a,int b){
int tmp = a;
a = b;
b = tmp;
}
int main(){
int a = 10;
int b = 100;
change(a,b);
printf("a = %d , b = %d \n",a,b);
return 0;
}正确做法，使用指针间接操作：使函数和main中的变量内存地址相同，再交换值
#include<stdio.h>
void change(int *a,int *b){
int tmp = *a;
*a = *b;
*b = tmp;
}
int main(){
int a = 10;
int b = 100;
change(&a,&b);
printf("a = %d , b = %d \n",a,b);
return 0;
}3.指针变量内存地址修改
注：需要加上“ 0x ”
#include<stdio.h>
int main (){
int a = 10;
printf("adress is 0x%p\n",&a);
//修改地址为 0x000000000061FE66
int *p = (int *)0x000000000061FE66;
//unsigned int *p = (unsigned int *)0x000000000061FE66;
//volatile unsigned int *p = (volatile unsigned int *)0x000000000061FE66;
printf ("adressP is 0x%p",p);
return 0;
}为防止分配的地址被自动优化，可以采用以下写法，添加关键字
unsigned int *p = (unsigned int *)0x000000000061FE66;
volatile unsigned int *p = (volatile unsigned int *)0x000000000061FE66;4.综合小练习
输入三个数分别等于a,b,c
用函数进行排序，使得数值从大到小分配给a,b,c
#include<stdio.h>
void sort(int *a,int *b,int *c){
int tmp;
if(*a<*b){
tmp = *a;
*a = *b;
*b = tmp;
}
if(*b<*c){
tmp = *c;
*c = *b;
*b = tmp;
}
if(*a<*b){
tmp = *a;
*a = *b;
*b = tmp;
}
}
int main(){
int a,b,c;
puts("请输入三个数字，将自动按照大小排序分配给a,b,c");
scanf("%d%d%d",&a,&b,&c);
sort(&a,&b,&c);
printf(" a = %d \n b = %d \n c = %d ",a,b,c);
return 0;
}二 数组指针
1.基本概念
数组的首地址就是首个元素的地址，数组名就是数组的首地址。
#include<stdio.h>
int main(){
int arr[3] = {1,2,3};
int *p;
//两种取址方式
p = &arr[0];
p = arr;
for(int i = 0;i<3;i++){
printf("%d元素是：%d\n",i+1,*(p+i));
printf("address = %p\n",p+i);
}
return 0;
}输出结果：
1元素是：1
address = 000000000061FE04
2元素是：2
address = 000000000061FE08
3元素是：3
address = 000000000061FE0C
调试模式：
gcc arr.c -g
gdb a.exe//进入调试模式
r//运行
q//退出
2.案例练习：将原数组改为倒序
#include<stdio.h>
//打印数组
void printarr(int *p_arr,int len){
for(int i = 0;i<len;i++){
printf("arr[%d] = %d;\n",i,p_arr[i]);
}
}
//使得数组变为倒序
void Reverse(int *p_arr,int len){
//不需要如下这样，因为5/2 == 4/2
//int index = (len-1)/2;
int index = len/2;
for(int i = 0;i<index;i++){
/*
两种表达方式，直接交换值：
int tmp = p_arr[i];
p_arr[i] = p_arr[len-1-i];
p_arr[len-1-i] = tmp;
*/
//指针偏移：
int tmp = *(p_arr+i);
*(p_arr+i) = *(p_arr+(len-1-i));
*(p_arr+(len-1-i)) = tmp;
}
}
int main(){
int arr1[5] = {1,3,5,7,9};
int arr2[6] = {2,4,6,8,10,12};
int len1 = sizeof(arr1)/sizeof(arr1[0]);
int len2 = sizeof(arr2)/sizeof(arr2[0]);
puts("原数组1为：");
printarr(arr1,len1);
puts("原数组2为：");
printarr(arr2,len2);
Reverse(arr1,len1);
Reverse(arr2,len2);
puts("倒数组1为：");
printarr(arr1,len1);
puts("倒数组2为：");
printarr(arr2,len2);
return 0;
}输出结果为：
原数组1为：
arr[0] = 1;
arr[1] = 3;
arr[2] = 5;
arr[3] = 7;
arr[4] = 9;
原数组2为：
arr[0] = 2;
arr[1] = 4;
arr[2] = 6;
arr[3] = 8;
arr[4] = 10;
arr[5] = 12;
倒数组1为：
arr[0] = 9;
arr[1] = 7;
arr[2] = 5;
arr[3] = 3;
arr[4] = 1;
倒数组2为：
arr[0] = 12;
arr[1] = 10;
arr[2] = 8;
arr[3] = 6;
arr[4] = 4;
arr[5] = 2;
本案例的关键在于倒序排序，采用了两种方法：
int index = len/2;
for(int i = 0;i<index;i++){
两种表达方式，直接交换值：
int tmp = p_arr[i];
p_arr[i] = p_arr[len-1-i];
p_arr[len-1-i] = tmp;
指针偏移：
int tmp = *(p_arr+i);
*(p_arr+i) = *(p_arr+(len-1-i));
*(p_arr+(len-1-i)) = tmp;
}3.二维数组指针
a = a[0] = &a[0] = a[0][0] = &a[0][0];
a+1 = a[1] = &a[1] = a[1][0] = &a[1][0];
a[2] = &a[2][0];
a[2]+3 = &a[2][3]；
a[1] + 2 = *(a+1) + 2 = &a[1][2]; //a[1][2]的地址
*(a[1]+2) = * ( *(a+1) + 2 ) = a[1][2]; //a[1][2]的值
#include<stdio.h>
int main(){
//二维数组地址
int a[3][4] = {0};
//a = &a[0];
//a[0] = &a[0][0];
printf("0x%p\n",a);
printf("0x%p\n\n",&a[0]);
printf("0x%p\n",a[2]);
printf("0x%p\n\n",&a[2][0]);
printf("0x%p\n",a[2]+1);
printf("0x%p\n\n",&a[2][1]);
puts("================================");
int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int *p;
//以下赋值写法会产生警告
//p = arr;
//warning: assignment to 'int *' from incompatible pointer
//应该
p = arr[0];
//或
//p = &(arr[0][0]);
//p = (int *)arr;
//但是也可以
int (*p2)[4];
p2 = arr;
printf("0x%p\n",p);
printf("0x%p\n",p2);
return 0;
}输出结果：
0x000000000061FDD0
0x000000000061FDD0
0x000000000061FDF0
0x000000000061FDF0
0x000000000061FDF4
0x000000000061FDF4
================================
0x000000000061FDA0
0x000000000061FDA0
可见 a[0][0] , a[0][1] 地址差4位
4.案例：用函数让用户自己输入一个数组，并且使用户可以提取第任意行列上的数值
#include<stdio.h>
//输入函数
void input(int (*p_arr)[4],int hang,int lie){
for(int i = 0;i<hang;i++){
for(int j = 0;j<lie;j++){
printf("第%d行%d列：",i+1,j+1);
scanf("%d",&(*(*(p_arr+i)+j)));
}
}
}
//打印出来，测试输入是否正确
void print_arr(int (*p_arr)[4],int hang,int lie){
for(int i = 0;i<hang;i++){
for(int j = 0;j<lie;j++){
printf("%d\t",*(*(p_arr+i)+j));
}
putchar('\n');
}
}
//提取函数
void get(int (*p_arr)[4]){
int x,y;
scanf("%d%d",&x,&y);
printf("第%d行%d列：%d",x,y,*(*(p_arr+x-1)+y-1));
}
int main(){
int arr[3][4];
int hang = sizeof(arr)/sizeof(arr[0]);
int lie = sizeof(arr[0])/sizeof(arr[0][0]);
//提示用户输入
puts("请输入一个三行四列的二维数组");
//调用输入函数
input(arr,hang,lie);
//test
//print_arr(arr,hang,lie);
//提示用户提取
puts("请分别输入 行数 列数 提取二维数组中的元素");
//调用提取函数
get(arr);
return 0;
}三 函数指针
1.函数地址
函数名就是地址，函数指针为函数储存空间的起始地址
指针创建的对比：
int a;
int *p;
char c;
char *p_c;
int get(int a,int b);
函数指针：
int (*p_get)(int a,int b);
返回指针的函数：
int *p_get(int a,int b);函数指针的用法：
#include<stdio.h>
void Welcome(){
puts("Welcome!!!!!!!!");
}
int main(){
//一般做法
Welcome();
//创建函数指针
void (*p)();
//指针指向函数地址
p = Welcome;
//调用函数
(*p)();
return 0;
}函数指针里变量名用不到就不用写，如：
int (*p)(int ,int );
四 指针数组
1.指针数组
基本概念：
定义一个指针数组
int* p[4];
而不是下面的数组指针
int (*p)[4];使用方式：
#include<stdio.h>
int main(){
//定义一个指针数组
//int* p[4];
//而不是下面的数组指针
//int (*p)[4];
int a = 1,b = 2,c = 3,d = 4;
int* p[4] = {&a,&b,&c,&d};
for(int i=0;i<4;i++){
printf("0x%p : %d\n",p[i],*p[i]);
}
return 0;
}输出结果：
0x000000000061FE18 : 1
0x000000000061FE14 : 2
0x000000000061FE10 : 3
0x000000000061FE0C : 4
2.函数指针数组
void (*function[3])() = {Welcome,ILoveU,Goodbye};
#include<stdio.h>
void Welcome(){
puts("Welcome!!!!!!!!");
}
void ILoveU(){
puts("ILoveU!!!!!!!!");
}
void Goodbye(){
puts("Goodbye!!!!!!!!");
}
int main(){
//函数指针数组
void (*function[3])() = {Welcome,ILoveU,Goodbye};
for(int i=0;i<3;i++){
(*function[i])();
}
return 0;
}3.案例：a个学生分别b门成绩，输入学生序号可输出学生全部成绩，用指针函数来实现
#include<stdio.h>
//a个学生分别b门成绩，输入学生序号可输出学生全部成绩，用指针函数来实现
//需求2：找出有不合格课程的学生序号及其成绩单
//打印全部成绩
void printAll(int (*score)[4]){
for(int i=0;i<3;i++){
printf("学生%d：",i+1);
for(int j=0;j<4;j++){
printf("科目%d：%d",j+1,score[i][j]);
}
putchar('\n');
}
}
//传统方法
void printEachScore(int (*score)[4],int n){
for(int i=0;i<4;i++){
printf("科目%d：%d\t",i+1,score[n-1][i]);
}
}
//指针函数
int* getScore(int (*score)[4],int n){
int *p;
p = (int *)(score + n-1);
return p;
}
//找不及格序号
int find(int (*score)[4]){
int n;
for(int i=0;i<3;i++){
for(int j=0;j<4;j++){
if(score[i][j] < 60){
n = i;
}
}
}
return n;
}
int main(){
int score[3][4] = {{55,66,77,88},{66,77,88,99},{33,44,55,66}};
int *p_n;
int n;
puts("请输入序号：");
scanf("%d",&n);
//printAll(score);
//printEachScore(score,n);
//调用指针函数
for(int i=0;i<4;i++){
printf("科目%d：%d\t",i+1,getScore(score,n)[i]);
}
putchar('\n');
//找不及格学生及其成绩单
printf("学生%d有不合格科目\n",find(score)+1);
for(int i=0;i<4;i++){
printf("科目%d：%d\t",i+1,score[find(score)][i]);
}
return 0;
}运行结果：
请输入序号：
2
科目1：66 科目2：77 科目3：88 科目4：99
学生3有不合格科目
科目1：33 科目2：44 科目3：55 科目4：66
五 二级指针（多级指针）
1.指针的指针
#include<stdio.h>
int main(){
int data = 100;
int *p = &data;
printf("data的地址即p：\n%p\n,保存的值data即*p：\n%d\n",p,*p);
printf("p的地址：\n%p\n",&p);
int *p_p = &p;
printf("p_p保存了p的地址：\n%p\n",p_p);
printf("*p_p是p：\n%p\n",*p_p);
return 0;
}运行结果：
data的地址即p：
000000000061FE14
,保存的值data即*p：
100
p的地址：
000000000061FE08
p_p保存了p的地址：
000000000061FE08
*p_p是p：
000000000061FE14
==============================
问题在于：
int *p_p = &p;
会产生不可消除的警告。
并且*p_p永远无法访问到data的值，
此时需要引入二级指针。
2.二级指针
引入二级指针改进上述代码：（三级指针同理可推）
#include<stdio.h>
int main(){
int data = 100;
int *p = &data;
printf("data的地址即p：\n%p\n,data即*p：%d\n",p,*p);
printf("p的地址：\n%p\n",&p);
/*
指针的指针：
int *p_p = &p;
printf("p_p保存了p的地址：\n%p\n",p_p);
printf("*p_p是p：\n%p\n",*p_p);
*/
//二级指针
int **p2;
p2 = &p;
printf("p2保存了p的地址：\n%p\n",p2);
printf("*p2是p：\n%p\n",*p2);
printf("**p2是data：%d\n",**p2);
return 0;
}运行结果：
data的地址即p：
000000000061FE14
,data即*p：100
p的地址：
000000000061FE08
p2保存了p的地址：
000000000061FE08
*p2是p：
000000000061FE14
**p2是data：100
3.应用案例：在封装函数中使得main的指针指向任意值
丑图方便自己理解的：
#include<stdio.h>
void Change_p(int *arr,int n,int **p){
*p = arr + n-1;
}
int main(){
int arr[5] = {11,22,33,44,55};
int *p;
int n;
puts("which one in five?");
scanf("%d",&n);
Change_p(arr,n,&p);
printf("Here:%d",*p);
return 0;
}4.二级指针与二维数组
直接用没啥关联，不能直接用，会崩溃，处理办法如下
#include<stdio.h>
int main(){
int arr[3][4] = {
{55,66,77,88},
{66,77,88,99},
{33,44,55,66}
};//int (*p2)[4] = arr;
int **p;
p = arr;
printf("p = 0x%p\n",p);
printf("*p = %d\n",*p);
printf("*p = 0x%p\n",*p);//野指针
printf("*arr = 0x%p\n",*arr);//跳转到列地址
//**p = 100;//对野指针赋值，段错误
//正确做法如下：
int (*p2)[4] = arr;
int **p3 = &p2;
**p3 = 100;
printf("arr[0][0] = %d\n",arr[0][0]);
return 0;
}运行结果：
p = 0x000000000061FDE0
*p = 55
*p = 0x0000004200000037
*arr = 0x000000000061FDE0
arr[0][0] = 100
2079
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
