数组指针与指针数组
数组指针
概念：
数组指针是指向数组的指针。
特点：
先有数组，后有指针 它指向的是一个完整的数组。
一维数组指针：
语法:
1 数据类型 (*指针变量名)[容量]；案例：
/**
* 数组指针：指向数组的指针
*/
#include <stdio.h>
int main()
{
// 一维数组指针
// 先有数组，再有指针
int arr[3] = {100,200,300};
// 获取数组的元素个数
int len = sizeof arr / sizeof arr[0];
// 定义一个数组指针，指向arr数组
// 数组指针的语法：数据类型 (*指针变量名)[容量];
int (*p)[3] = &arr;// 此时p不是指向arr数组的第一个元素，而是指向arr这个数组本身
printf("%p\n",p);
// p++; 此时p++会跳出整个数组
// printf("%p\n",p);
printf("%d\n",(*p)[2]);// 300
// 遍历
for(int i = 0; i < len; i++)
{
printf("%d\n",(*p)[i]);
}
printf("\n");
// int *p = &arr[0] | arr;// 这种写法，代表p指向的不是数组本身，是数组中的第一个元素
}
二维数组指针
语法：
1 数据类型 (*指针变量名)[容量]；
案例：
/**
* 二维数组指针案例
*/
#include <stdio.h>
int main()
{
// 数组指针：先有数组，再有指针
int arr[][3] = {{100,200,300},{1000,2000,3000},{10,20,30}};
// 创建一个数组指针，指向二维数组
// int (*p)[3] = &arr; // p[0] -->{100,200,300},p[1] -->{1000,2000,3000}，也就是说：
p[0] = 元素100的首地址，p[1] = 元素1000的首地址
int (*p)[3] = arr; // arr等价于&arr[0],p[0] = 元素100的首地址
// 获取元素100？
printf("100-%d\n",(*p)[0]);// arr[0][0]
// 获取元素2000?
printf("2000-%d,%d,%d\n",*(*(p+1)+1),*(p[1]+1),p[1][1]);// arr[i][j] ===> *(*(p+i)+j)
===> *(p[i]+j) ===> p[i][j]
return 0;
}指针和数组中符号优先级： () > [] > *
指针数组
概念：
指针数组是一个数组，数组中的每个元素都是一个指针。
特点
先有“指针”，
后有“数组” 指针数组的本质是一个数组，只是数组中的元素类型为指针。
语法：
1 数据类型 *数组名[容量];案例：
/**
* 指针数组
*/
#include <stdio.h>
int main()
{
// 定义三个变量
int a = 10, b = 20, c = 30;
// 定义指针数组，指针数组用来存放指针（变量或者常量的内存地址）
int *arr[3] = {&a,&b,&c};
// 获取数组的大小
int len = sizeof arr / sizeof arr[0];
// 遍历数组
for(int i = 0; i < len; i++)
{
printf("%3d",*(arr[i])); // 输出每个指针所指向的值，需要解引用
}
printf("\n");
return 0;
}建议：我们一般使用指针数组处理字符串
字符串指针
字符串实现
在C语言中，表示一个字符串有以下两种形式：
1. 用字符数组存放一个字符串
2. 用字符指针指向一个字符串
案例：
/**
* 字符串的两种实现方式
*/
#include <stdio.h>
/* 使用字符数组实现 */
void fun()
{
// 定义伪字符串
char str[] = "I Love Your!";
printf("%s\n",str);
}
/* 使用字符指针实现 *
void fun1()
{
// 定义伪字符串
char *str = "I Love Your!";
printf("%s\n",str);
}
int main()
{
fun();
fun1();
return 0;
}注意：字符数组和字符指针变量都能实现字符串的存储与运算。
字符数组和字符指针的联系
字符数组由元素组成，每个元素中存放一个字符，而字符指针变量中存放的是地址，也能作为函数 参数。
只能对字符数组中的各个元素赋值，而不能用赋值语句对整个字符数组赋值。
字符数组名虽然代表地址，但数组名的值不能改变。因为数组名是常量。
对于字符串中字符的存取，可以用下标法，也可以用指针法。
案例：
/**
* 字符数组和字符指针的联系
*/
#include <stdio.h>
int main()
{
// 使用两种方式定义字符串
char str1[] = "你好，马杰克！";
char *str2 = "您好，马应龙！";
// 测试赋值
// str1 = "你好,龙瑞！"; // 不能对字符数组整体赋值，如果要赋值，请使用string.h中strcpy()
str2 = "你好,姚科！";
// 打印输出
printf("%s\n%s\n",str1,str2);
char a[] = "I love you!";
char *b = "I love you!";
// 使用下标法和指针法访问字符串
printf("%c\n%c\n",a[4],*(b+4));// v v 空格也是占位的
return 0;
}
字符串指针作为形式参数
实参与形参都可以是字符数组
实参用字符数组，形参用字符指针（在函数内部不能对字符串中的字符做修改）
test5(char *arr,int len)
{
arr[2] = 'A'; // 错误，字符串常量一旦创建，就不能被改变
}
main(){
char arr[] = "abc"; // 字符串常量，常量是不可修改的
test(arr,3);
}实参和形参都是指针变量（在函数内部不能对字符串中的字符做修改）
test(char *arr,int len)
{
arr[2] = 'A'; // 错误
}
main()
{
char arr[] = "abc";
char *p = arr;// &arr[0]
test(p,3);
}实参是指针类型，形参是字符数组
注意：
1. 字符数组在创建的时候，会在内存中开辟内存空间，内存空间可以存放字符数据；字符指针在创建 的时候，需要依赖于字符数组，字符指针在内存中开辟的内存空间中，存放的是数组元素的内存地 址。字符指针的创建依赖于字符数组，字符数组可以独立存在，而字符指针不能独立存在。
2. 字符数组可以初始化，但是不能赋值；字符指针可以初始化，也可以赋值。
// 字符数组
char str1[11] = "I love You!";
str1 = "Home"; // 错误
str1[] = "home"; // 错误
// 字符指针
char *str2 = "I love You!";
str2 = "home";// 正确案例1：
/**
* 字符指针作为函数参数：用函数调用实现字符串，复制以及计算字符串长度。
*/
#include <stdio.h>
/* 定义一个函数，传递拷贝的字符串，返回字符串长度 */
int str_copy(char *str1,char *str2)
{
int i = 0; // 循环变量
while(str1[i]!='\0')
{
// 实现拷贝
str2[i] = str1[i];
i++;
}
// 拷贝结束之后，一定要给字符串加上结束符号\0
str2[i] = '\0';
return i;
}
int main()
{
// 定义两个数组，从键盘录入字符串
char str1[20],str2[20];
printf("请输入一个字符串：\n");
scanf("%s",str1);
printf("str1=%s\n",str1);
int len = str_copy(str1,str2);
printf("str2=%s\n",str2);
printf("len=%d\n",len);
return 0;
}案例2：
/**
* 给定一个字符串，截取start到end之间字符串，含头不含尾
*/
#include <stdio.h>
/* 字符串截取函数 */
int str_split(char *str,int start,int end,char *temp)
{
// 定义一个循环变量
int i = 0,k = 0;
// 定义一个字符指针，用来接收str中截取到字符串
// 循环遍历每一个字符
while(str[i]!='\0')
{
if(i>= start && i < end)
{
temp[k] = str[i];
k++;
}
i++;
}
temp[k] = '\0';
// 更新str中的数据
printf("%s\n",temp);
return k;
}
int main()
{
char *str = "abcdefg";
char temp[100];
int len = str_split(str,2,5,temp);
printf("str=%s,len=%d\n",temp,len);
return 0;
}函数指针与指针函数
函数指针
定义：函数指针本质是指针，它是函数的指针（定义一个指针变量，变量中存储了函数的地址）。 函数都有一个入口地址，所谓指向函数的指针，就是指向函数的入口地址。这里函数名就代表入口 地址。
函数指针存在的意义：
1. 让函数多了一种 调用方式
2. 函数指针作为形参，可以形式调用（回调函数）
定义格式：
1 返回值类型（*变量名）(形式参数列表)；
举例：
int (*p) (int a,int b);
函数指针的初始化
1. 定义同时赋值
// 得先有函数，才能定义这个函数的指针
int fun(int a,int b){..}
// 定义函数指针并给它赋值
int (*p) (int a,int b) = fun;// fun不能跟()
2. 先定义后赋值
// 得先有函数，才能定义这个函数的指针
float fun(int a,double b,char c){..}
// 先定义函数指针
float (*p) (int a,double b,char c);
// 赋值
p = fun;总结：
1. 函数指针指向的函数要和函数指针定义的返回值类型，形参列表对应，否则编译报错
2. 函数指针是指针，但不能指针运算，如p++等，没有实际意义。
3. 函数指针作为形参，可以形成回调（回调后面讲）。
4. 函数指针作为形参，函数调用时的实参只能是与之对应的函数名，不能带小括号。
5. 函数指针的形参列表中的变量名可以省略。
案例：
/**
* 函数指针：指向函数的指针变量就是函数指针
需求：求a，b两个数的最大值
*/
#include <stdio.h>
int max(int a,int b)
{
if(a > b)
{
return a;
}
return b;
}
int main()
{
int a = 3,b = 2,c;
// 普通函数调用
c = max(a,b);
printf("%d,%d两个数中的最大值是：%d\n",a,b,c);
// 通过指针变量访问它指向的函数
// 创建指针并初始化
int (*p)(int,int) = max;
// 调用函数指针
c = p(a,b);
printf("%d,%d两个数中的最大值是：%d\n",a,b,c);
// 调用函数指针
c = (*p)(a,b);
printf("%d,%d两个数中的最大值是：%d\n",a,b,c);
return 0;
}指针函数
定义：本质是函数，这个函数的返回值类型是指针，这个函数称为指针函数。
定义格式
指针类型 函数名(形参列表)
{
函数体;
return 指针变量;
}举例：
int *get(int a)
{
int *b = &a;
// return &a; // 编译报警告
return b;
}注意：
在函数中不要直接返回一个局部变量的地址，因为函数调用完毕后，布局变量会被回收，使 得返回的地址就不明确，此时返回的指针就是野指针。
解决方案：
如果非要访问，可以给这个局部变量添加 static ，可以延长它的生命周期，从二避免野指针 （尽量少用，因为存在内存泄漏）。
案例：
/**
* 指针函数：函数的返回值是指针类型
需求：有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用
指针函数来实现。
*/
#include <stdio.h>
/* 定义一个函数，传入学生的序号，返回这个学生的所有课程成绩 */
float *search(float (*p)[4],int n)
{
// 定义一个指针，用来接收查询到的某个学生的所有课程
float *pt;
pt = *(p+n);
return pt;
}
int main()
{
// 准备所有学生的成绩
float score[][4]={{60,70,80,90},{56,66,76,76},{35,68,90,37}};
int i,m;
float *p;
printf("请输入学生序号(0~2)：\n");
scanf("%d",&m);
printf("第%d个学生的成绩：\n",m);
p = search(score,m);// 函数返回值为行的首地址
// 遍历
for(i = 0; i < 4;i++)
printf("%5.2f\t",*(p+i));
printf("\n");
return 0;
}
扫一扫
139
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
