c语言第16天笔记

数组指针与指针数组

数组指针

概念：

数组指针是指向数组的指针。

特点：

先有数组，后有指针 它指向的是一个完整的数组。

一维数组指针：

语法:

数据类型 (*指针变量名)[容量]；

案例：

/**
* 数组指针：指向数组的指针
*/
#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指向的不是数组本身，是数组中的第一个元素
}

二维数组指针

语法：

数据类型 (*指针变量名)[容量]；

案例：

/**
* 二维数组指针案例
*/
#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;
}

指针和数组中符号优先级： () > [] > *

指针数组

概念：

指针数组是一个数组，数组中的每个元素都是一个指针。

特点： 先有“指针”，后有“数组” 指针数组的本质是一个数组，只是数组中的元素类型为指针。

语法：

数据类型 *数组名[容量];

案例：

/**
* 指针数组
*/
#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. 函数指针作为形参，可以形式调用（回调函数）

定义格式：

返回值类型（*变量名）(形式参数列表)；

举例：

 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);// 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;
}

野指针、空指针

野指针

定义：访问了一个已经销毁或者访问受限的内存区域外的指针，这个指针就被称为野指针。

野指针产生的场景：

1. 变量未初始化，通过指针访问该变量

int a;
int *p = &a; // p就是野指针
ptf(*p); // 访问野指针，但是数据不安全

2. 指针变量未初始化

int *p = NULL; // 此时的p也是野指针
ptf(*p);

3. 指针指向的内存空间被（free函数）回收了---后面讲

4. 指针函数中直接返回了局部变量的地址。

5. 指针指向数组以外的地址（下标越界）

如何避免野指针：

写代码要养成两个习惯（通过编码规范避免）

1. 指针变量幻及时初始化，如果暂时没有对应的值，建议赋值为NULL;

2. 数组操作（遍历,指针运算）时，注意数组的长度，避免越界

3. 指针指向的内存空间被回收，建议给这个指针变量赋值为NULL;

int *p = (int*)malloc(10);// 动态内存分配
free(p);// 动态内存释放
p = NULL;// p不指向任何空间

4. 指针变量使

int *p = NULL;
if(!p)
{
return -1;
}

用之前要检查它的有效性（以后开发中要做非空校验）

说明：NULL是空常量，它的值是0，这个NULL一般存放在内存中的0x00000000位置，这个地址只 能存放NULL，不能被其他程序修改。

空指针

空指针，又被称作悬空指针：当一个指针的值是NULL，这个指针被称为空指针；对空指针访问会运行 报错（段错误）

二级指针

定义：二级指针，又被称作多重指针，引用一级指针的地址，此时这个指针变量就得定义成二级指 针。

int a = 10;
int *p = &a;
int **w = &p;

定义格式：

数据类型 **变量名 = 指针数组的数组名或者一级指针的地址

// 指针数组
int array = {1,2,3};
int *arr = {&array[0],&array[1],&array[2]};// 指针数组
// 一级指针
int a = 10;
int *p = &a; // 一级指针

举例：

// 字符型指针数组
char *arr[3] = {"abc","aaa034","12a12"};// 等效于：char arr[3][6] = {"abc","aaa034","12a12"}
// 定义二级指针并赋值(指针需要跟依赖的源同类型)
char **p = arr;// 正确
int array[2][3] = {{1,2,3},{11,22,33}};
int **k = array;// 编译报错，数据类型不相符（二维数组不等于指针数组）
int a = 90;
int *p = &a;// 一级指针
int **k = &p;// 正确，二级指针

结论

1. 二级指针和指针数组是等效，和二维数组不等效

2. 二维数组和数组指针是等效，和二级指针不等效

二级指针的用法：

1. 如果是字符的二级指针，可以像遍历字符串数组一样遍历它

2. 如果是其他的二级指针，就需要解引用两次访问它所指向的数据

案例：

/**
* 二级指针案例：使用指向指针数据的指针变量。
*/
#include <stdio.h>
void fun1()
{
char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"};
// 定义一个二级指针
char **p;
// 定义循环变量
int i = 0;
// 遍历指针数组
do
{
p = name + i;
printf("%s\n",*p);
i++;
}while(i < 5);
printf("\n");
}
void fun2()
{
int arr1[5] = {11,12,13,14,15};
// 创建一个指针数组
int *arr[] = {&arr1[0],&arr1[1],&arr1[2],&arr1[3],&arr1[4]};
int **p = arr,i = 0;
// 遍历
for(;i < 5; i++)
{
// printf("%5d",**(p+i));
printf("%5d",**p);
p++;
}
printf("\n");
}
int main()
{
fun1();
fun2();
}

main函数的原型

定义：main函数有多种定义格式，main函数也是函数，函数相关的结论对main函数也有效（也可 以定义main函数的函数指针）。

main函数的完整写法：

int main(int argc,char *argv[]){}
int main(int argc,char **argv){}

扩展写法：

int main(){}
int main(void){}
void main(){}
main(){} ---- int main(){}
void main(void){}
int main(int a){}
int main(int a,int b,int c){}
...

说明：

1. argc，argv是形参的名称，它们俩可以修改

2. main函数的扩展写法有些编译器不支持，编译报警告

3. argc和argv的常规写法： argc：存储了参数的个数 argv：存储了所有参数的字符串形式

4. main函数是系统通过函数指针的回调形式调用的 注意：如果一个函数没有写返回值类型，这个函数的默认返回类型是int。

案例：

/**
* main函数
*/
#include "stdio.h"
int main(int argc,char **argv)
{
int k;
for (k=1;k < argc;k++)
printf("%s\n",argv[k]);
}

常量指针与指针常量

常量：分为字面量和只读常量，字面量（就是我们平时直接操作的如： printf(12)|printf("hello")）；只读常量使用关键字 const 修饰，凡是被这个关键字修饰的变量，一 旦赋值，值就不能改变。

语法：

// 字面量举例，字面量是一种匿名的常量
printf(12);
printf("请输入一个数：\n");
// 只读常量
const int a = 10;
a = 21;// 编译错误，因为此时这个变量是只读常量，所以不可更改其值

常量指针

定义：常量的指针，本质是一个指针，指针指向的数据不能改变。
定义格式：

const 数据类型 *变量名;

举例：

const int *p; // p就是常量指针

结论

1. 常量指针指向的数据不能被改变（不能解引用间接修改数据）

2. 常量指针的地址可以改变。 应用场景：作为形式参数，实际参数需要给一个常量。

案例：

#include <stdio.h>
/* 常量指针 */
void test1()
{
// 定义变量
int a = 10;
// 定义常量指针
const int *p = &a;
// *p = 100; // 编译报错，常量的值不能修改（常量指针指向地址空间的数值不能修改）
printf("%d\n",*p);// 10
int b = 90;
p = &b; // 编译通过，常量的地址可以修改（常量指针指向的地址空间可以发生改变）
printf("%d\n",*p);// 90
}
int main()
{
test1();
}

指针常量

定义：指针的常量，指针的指向不能改变

定义格式：

数据类型* const 变量名；

结论：

1. 指针常量的指向不能被改变（不能给指针变量重新赋地址值）

2. 指针常量指向的数据可以改变。

注意：指针常量在定义时就要赋值；不能先定义后赋值，否则编译报错。

案例：

/**
* 常量指针与指针常量
*/
#include <stdio.h>
/* 指针常量 */
void test2()
{
// 定义变量
int a = 10;
// 定义指针变量
int* const p = &a;
// 错误写法：先定义，后赋值（编译报错）
// int* const p;
// p = &a;
// 间接取数据
pirntf("%d\n",*p);
// int b = 200;
// p = &b;// 编译报错，地址不能改变
*p = 200;
printf("%d\n",*p);// 200
}
int main()
{
test2();
}

常量指针常量

定义语法：

const 数据类型* const 变量名;

举例：

const int* const p; // 常量指针常量

作用：p的指向不能被改动（地址），p指向的数据不能被改（地址对应内存中存放的数据）

动态内存分配

我们要想实现动态内存分配，就需要学习标准C提供的函数库：

1. 函数所属的库文件

2. 函数的原型-函数的声明

1. 函数名

2. 形参

3. 返回值类型

3. 函数的功能

注意：内存分配函数在申请内存时，建议用多少申请多少，可以有少量的预留量；但不能越界访问 （虽然编译和运行不报错，但数据不安全）

常用函数

malloc

头文件： #include

函数功能：C 库函数 void *malloc(size_t size) 分配所需的内存空间，并返回一个指向它的指 针。

函数原型：

函数名：

malloc

形式参数：size_t size：内存块的大小，以字节为单位。本质上就是一个 unsigned int

返回值类型：void* ：该函数返回一个指针，指向已分配大小的内存，如果请求失败，返回 NULL。

举例：

int *p = (int*)malloc(4);

说明：

1. malloc函数分配的内存没有默认值，是不确定数，大概率是0；

2. malloc函数申请的内存空间连续。

calloc 头文件： #include

函数功能：C库函数 void * calloc(size_t nitems,size_t size) 分配所需的内存空间，并返回一 个指向它的指针。

malloc和calloc之间不同点事，malloc不会设置内存为零，而calloc会设置内存为零。

函数原型： void *calloc(size_t nitems,size_t size)

函数名：calloc 形式参数：

size_t nitems：申请多少个

size_t size：一个占几个内存单元（一个内存单元 等于 一个字节）

返回值类型：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回 NULL。

举例：

int *p = (int*)calloc(3,4); // p指向的空间的大小是12个字节
if(!p) printf("内存申请失败！\n");

说明：

1. calloc函数分配的内存有默认值，每个内存单元都是0

2. calloc函数申请的内存空间连续

3. calloc大多时候为数组中的元素申请内存 转存栈中数组中的数据：

int arr[3] = {10,20,30}; // 在栈区
int *p = (int*)calloc(3,4); // 申请内存，在堆区
if(!p) puts("内存申请失败！");
// 转存
for(int i = 0;i < 3; i++)
p[i] = arr[i];
// 遍历
for(int i = 0;i < 3; i++)
printf("%d,",p[i]);
printf("\n");
// p使用完，记得释放内存
free(p);
p = NULL; // 内存回收后，建议置空

realloc 头文件： #include

函数功能：尝试重新调整之前调用malloc或calloc所分配的ptr所指向的内存块的大小。

函数原型： void *realloc(void *ptr,size_t size)

函数名：realloc

形式参数：

void *ptr：是malloc或者calloc的返回值

size_t size：重新分配后的内存大小

返回值：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL。

案例：

int *p = (int*)malloc(4);
int *w = (int*)realloc(p,20);
// int *q = (int*)realloc(p,0); // 等效于free(p)

说明：

1. realloc以原来malloc返回的内存地址开始，分配总共20个字节的内存空间

2. 如果原来的内存空间后有20个连续空间，就扩容20-4 =16个内存单元，返回原来旧的内存首地 址。

3. 如果原来的内存空间后不够20个连续内存空间，就重新找一个内存地址开始，申请20个内存 单元。并将原来的数据拷贝到新的内存中，回收旧的内存单元，并返回新的内存首地址。

free

头文件： #include

函数功能：释放之前调用 malloc、calloc、realloc所分配的内存空间，是访问完记得使用NULL置 空。

函数原型： void free(void *ptr)

函数名：free

形式参数：

void *ptr：calloc,malloc.realloc的返回值

返回值类型：void：没有返回值

注意：

1. 堆内存中的指针才需要回收，栈中系统会自动回收

2. 堆内存不能重复回收，运行会报错

说明：

1. 堆的内存空间相比较栈要大很多

2. 内存分配函数返回的指针变量可以参与运算（只读），但不能被修改（p++或者p+=i 是错误的）

扩展：形式参数和实际参数的对应关系

//形式参数和实际参数的对应关系
#include <stdio.h>
//void test(int arr[]) //可以
//void test(int arr[2]) //可以
//void test(int * arr) //可以
//void test(int *arr[]) //不可以，编译报错
//void test(int ** arr) //不可以
//void test(int (*arr)[]) //不可以
//---------------------------------
//void test2(int * arr[]) //可以
//void test2(int ** arr) //可以
void test2(int (*arr)[]) //不可以
{
printf("test执行了\n");
}
int main()
{
/*
int arr[3]={0};
test(arr);
*/
int *arr[3] = {0};
test2(arr);
return 0;
}
//形式参数和实际参数的对应关系
#include <stdio.h>
//void test(int arr[2][3]) //可以
//void test(int arr[][3]) //可以
//void test(int arr[2][]) //不可以
//void test(int arr[][]) //不可以
//void test(int (*arr)[]) //可以
//void test(int(*)arr[]) //语法错误
//void test(int(*arr)[3])
//void test(int *arr[]) //不可以
//----------------------------------------
//void test2(int *arr[]) //可以
//void test2(int arr[][1]) //不可以
//void test2(int **arr) //可以
void test2(int(*arr)[]) //不可以
{
printf("test\n");
}
int main()
{
/*
int arr[2][3] = {0};
test(arr);
*/
/*
int a = 20;
int *arr[] = {&a};
test2(arr);
*/
int** p;
test3(p);
return 0;
}

void与void*的区别

定义：

void：是空类型，是数据类型的一种

void*：是指针类型，是指针类型的一种，可以匹配任意类型的指针，类似于通配符

void

说明：

void作为返回值类型使用，表示没有返回值；作为形参，表示形参列表为空，在调用函 数是不能给实参

举例：

// 函数声明
void fun(void); // 等效于 void fun();
// 函数调用
fun();

void*

说明：

void*是一个指针类型，但该指针的数据类型不明确，无法通过解引用获取 内存中的数据， 因为 void* 不知道访问几个内存单元。

void*是一种数据类型，可以作为函数返回值类型，也可以作为形参类型

void*类型的变量在使用之前必须强制类型转换，明确它能够访问几个字节的内存空间

int *p = (int*)malloc(4);
double *p2 = (double*)malloc(8);

举例：

#include <stdio.h>
#include <stdlib.h>
// 函数定义
void* fun(void* p) // 指针函数（返回值类型是指针的函数，此时返回的是不明确类型，需要外部强转）
{
int *p;
// double *p;
// long *p;
// char *p;
return p;
}
// 函数调用
void main()
{
int *p;
void* a = fun(p);// 这种接收方式，实际上没有意义
printf("%p\n",a);// 可以正常打印，打印出一个地址
*a = 10;// 编译报错，void*变量不能解引用访问数据
int *w = (int*)a;
*w = 10;// 编译和运行正常，void*变量a在使用前已经强制类型转换了，数据类型明确了，访问的内存
单元明确了。
}

说明：

void*作为返回值类型：这个函数可以返回任意类型（ char*,int*,double*等 ）的指针。

void*作为形参类型：这个函数在调用时，可以给任意类型（ char*,int*,double*等 ）的指 针。

总结： void* 类似于通配符，不能对void*类型的变量解引用（因为不明确内存单元的大小）。

void*在间接访问（解引用）前要强制类型转换，但不能太随意，否则存和去的数据类型不 一致。

章节作业

1. 利用指针变量将一个数组中的数据反向输出。

2. 利用指针变量计算下标为奇数的数组的和；

3. 确认整型，字符型，浮点型指针变量的大小；

4. 利用指针变量输出字符数组中的所有字符。

5. 编写一个函数，用指针变量做参数，用于求出一个浮点型数组元素的平均值。

6. 编写函数,要求用指针做形参，分别实现以下功能：

（1）求一个字符串长度

（2）在一个字符串中统计大写字母的个数

（3）在一个字符串中统计数字字符的个数

7. 编写函数,要求用指针做形参，实现将二维数组(行列相同)的进行转置（行列数据互换）： int(*p) [N]

8. 编写函数,要求用指针做形参，实现统计二维数组上三角中的0 的数量：

9. 编写一个指针函数，返回二维数组中最大元素的地址。

10. 面试题

1）定义整形变量i； int i;

2）p为指向整形变量的指针变量； int *p;

3）定义整形一维数组p,它有n 个整形元素； int p[n];

4）定义一维指针数组p,它有n个指向整形变量的指针元素； int p[n];

5）定义p为指向（含有n个整形元素的一维数组）的指针变量；int(p)[n];

6）p为返回整形函数值的函数； int p();

7）p为返回一个指针的函数，该指针指向整形数据； int* p();

8）p为指向函数的指针变量，该函数返回一个整形值； int(*p)();

9）p是一个指向整形指针变量的指针变量； int **p;

11. 动态申请一个具有10个float类型元素的内存空间，从一个已有的数组中拷贝数据，并找出第一次出 现 12.35 的下标位置，并输出。

12. 动态申请一个整型数组，并给每个元素赋值，要求删除第3个元素；

13. 动态申请一个整型数组，并给每个元素赋值，要求在第4个元素后插入100；

14. 附加题【选做】： 编写一个函数，实现 memmove 的功能。