C语言基础⑨—

一、指针的引入

int —— 4位；float —— 4位；double —— 8位；short —— 2位；long —— 8位；

为函数修改实参提供支撑；
为动态内存管理提供支持；
为动态数据结构提供支持；
为内存访问提供另一种途径。

二、指针概述

内存地址：系统为了内存管理的方便，将内存划分为一个个的内存单元（1个内存单元占1个字节），并为每一个内存单元进行了编号，内存单元的编号称为该内存单元的地址。一般情况下，我们每一个变量都是由多个内存单元构成的，所以每个变量的内存地址，其实就是这个变量对应的第一个内存单元的地址，也叫首地址。
变量指针：变量地址称为该变量的指针。变量地址往往是指变量在内存中的第一个内存单元的编号（首地址）。
指针变量：存放其他变量地址的变量。
指向：指针变量中存放“谁”的地址，就说明该指针变量指向了“谁”。
* ：指针运算符

举例：指针初识

/**
* 指针 初识
*/
#include <stdio.h>

void main()
{
    int i = 3;//定义一个普通/一般变量
    int *i_point = &i;//定义一个指针变量，并赋值
    //指针变量的数据类型要和存储的地址变量类型一致

    printf("直接访问-%d\n",i);// 3 //访问普通变量（直接访问）

    printf("地址访问-%p\n",i_point);// %p访问地址 //访问指针（地址访问）

    printf("间接访问-%d\n",*i_point);// 3 //访问指针变量（间接访问）
}

三、指针变量的定义

语法：

数据类型 *变量列表；

举例：

int a;   //普通变量
int *a,*b;   //指针变量

注意：
虽然定义指针变量 *a ，是在变量名前加上 * ，但是实际变量名为 a ，而不是 *a ；
使用指针变量间接访问内存数据时，指针变量必须要有明确的指向；
如果想借助指针变量间接访问指针变量保存的内存地址上的数据，可以使用指针变量前加 * 来间接访问；指针变量前加 * ，也称为对指针变量解引用 。
int i = 5,*p; 
p = &i;// 将i的地址赋值给指针变量p 

printf("%d\n",*p);// 间接访问i的值，也成为解引用p对应地址空间的值
指针变量只能指向同类型的变量，借助指针变量访问内存，一次访问的内存大小取决于指针变量的类型；
指针变量在定义同时可以初始化：这一点和普通变量是一样的。
int i = 5;
int *p = &i;//定义的同时初始化

四、指针变量的使用

指针变量的赋值：

//方式1：
int a,*p;
p = &a;// 指针变量的值是其他变量的地址

//方式2：
int a,*p,*q = &a;
p = q;//p,q都是a的地址

操作指针变量的值：

int a,*p,*q = &a;
p = q;

printf("%p",q);//%p访问地址  此时返回的是变量a的地址空间

操作指针变量指向的值：

int a = 6,*q = &a;

printf("%d",*q);// 6 打印输出的是数据

1、两个有关运算符的使用

&：取地址运算符。&a是变量a的地址；
* ：指针运算符（“间接访问”运算符）。*p是指针变量 p 指向的对象的值。

举例：

/*
* 
*/
#include <stdio.h>

void main()
{
    int a,b;
    int *pointer_1,*pointer_2;

    a = 100;b = 10;

    pointer_1 = &a;
    pointer_2 = &b;

    printf("a = %d,b = %d\n",a,b);
    printf("pointer_1 = %d,pointer_2 = %d\n",*pointer_1,*pointer_2);
}

思考题：

举例：声明a,b两个一般变量，使用间接存储的方式进行数据的交换？

/**
 * 需求：声明a,b两个一般变量，使用间接存取的方式实现数据的交换？
 */
#include <stdio.h>
void main()
{
    // 声明5个变量
    int a = 3,b = 5,*p_a=&a,*p_b=&b,*p_t;
    // 交换前输出
    printf("%d,%d\n",*p_a,*p_b);    
    // 交换位置
    p_t = p_a;
    p_a = p_b;
    p_b = p_t;
    // 交换后输出
    printf("%d,%d\n",*p_a,*p_b);
}

举例：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。

/*
   需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。
 */
#include <stdio.h>
void main()
{
    int a = 3,b = 5,*p_a = &a,*p_b = &b,*p_t;
    if( a < b)
   {
        p_t = p_a;// 操作指针变量，不会影响到数据本身
        p_a = p_b;
        p_b = p_t;
   }
    printf("按从大到小输出a,b的值：%d > %d\n",*p_a,*p_b);
}

五、指针变量做函数参数

指针变量做函数参数往往传递的是变量的地址（首地址），借助于指针变量间接访问是可以修改实参变量数据的。

举例：

需求：要求用函数处理，用指针变量做函数的参数。

方式1：交换指向（指向的普通变量的值不变）

#include <stdio.h>
/* 需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。 */
/* 自定义函数，实现两个数的比较 */
void swap(int *p_a,int *p_b)
{
    int *p_t;
    // 这种写法，只会改变指向，不会改变地址对应空间的数据
    p_t = p_a;
    p_a = p_b;
    p_b = p_t;
    
    printf("%d > %d\n",*p_a,*p_b); // 5 > 3
}
void main()
{
    int a = 3,b = 5;
    if(a < b) swap(&a,&b); // int *p_a = &a,int *p_b = &b
    
    printf("%d > %d\n",a,b);// 3 > 5
    
    
}

方式2：交换值（指向的普通变量的值改变）

#include <stdio.h>
/* 需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。 */
/* 自定义函数，实现两个数的比较 */
void swap(int *p_a,int *p_b)
{
    int t;
    // 这种写法，只会改变指向，不会改变地址对应空间的数据
    t = *p_a;
    *p_a = *p_b;
    *p_b = t;
    
    printf("%d > %d\n",*p_a,*p_b); // 5 > 3
}
void main()
{
    int a = 3,b = 5;
    
    if(a < b) swap(&a,&b); // int *p_a = &a,int *p_b = &b
    
    printf("%d > %d\n",a,b);// 5 > 3
    
    
}

六、通过指针引用数组

1、数组元素的指针

数组指针：数组中的第一个元素的地址，也就是数组的首地址；
指针数组：用来存放数组元素地址的数组，称之为指针数组。

//定义一个一般数组
int a[] = {1,4,9};
//使用指针变量存储数组的第一个元素的首地址，也就是数组的首地址
int *p = &a[0];//数组首地址

//在C语言中，由于数组名代表数组的首地址，因此，数组名实际上也是指针
int *p = a;

//意味着:int *p = &a[0] 完全等价于 int *p = a;

printf("%d\n",*p);// 1

注意：

虽然我们定义了一个指针变量接收了数组地址，但不能理解为指针变量指向了数组，而应该理解为指向了数组的元素。

2、指针的运算

指针运算：指针变量必须要指向数组中的某个元素。

指针运算的说明
序号	指针运算	说明
1	自增：p++、++p、p = p+1 \| p+=1	让指针变量指向下一个元素
2	自减：p--、--p、p = p-1 \| p-=1	让指针变量指向上一个元素
3	加一个数：p+1	下一个元素的(首)地址
4	减一个数：p-1	上一个元素的(首)地址
5	指针相减：p1-p2	p1、p2之间相差几个元素
6	指针比较：p1<p2	前面的指针小于后面的指针 (操作系统在分配时按从小到大的顺序分配)

举例：元素个数

#include <stdio.h>
int main()
{
    // 一般数组
    int a[] = {1,3,5,7,9};
    // 计算数组中元素的个数
    // sizeof用法：sizeof(运算数) 或者 sizeof 运算数
    int len = sizeof a / sizeof a[0];
    // 创建指针变量
    int *p = a;
    // 创建循环变量
    register int i = 0;
    // 遍历
    for(;i < len; i++)
   {
        printf("[1] %d ",a[i]); // 下标法
        printf("[2] %d ",*(a+i));// 指针法，但是这种写法，需要注意，a+i无法修改数组，只读
        printf("[3] %d ",*(p+i));// 指针法，这种更为灵活，可读可写，建议这种写法p++;
 
        // printf("%d\n",*p); // 等价于上面写法
        // p++;
   }
    printf("\n");
    return 0;
}

举例：元素个数

#include <stdio.h>

int main()
{
    int a[] = {10,22,33,44,55,66,77,88};
    int *p = a;// 等价于 int *p = &a[0] 元素：10
    p++;// 指针+1，元素值不改变 元素：22
    printf("%d\n",*p);// p = p + 1 元素：22
    int x = *p++;// x = 22,p++ -- *p：33
    printf("%d,%d\n",x,*p);// *p++：先*p,在p++, 元素：22,33   
    int y = *(++p);// ++p, y = 44;
    printf("%d,%d\n",y,*p); // *(++p)：先p++,再*p，元素：44,44
    
   (*p)++;// 元素值+1,指针不改变
    printf("%d\n",*p);// index为3的元素值：44 + 1 = 45
    return 0;
}

3、数组名做函数参数

表现形式：

void fun(int *p1){}
void main()
{
    // 注意：如果实参和形参都是指针，我们的实参需要初始化
    int arr[2] = {23,34};
    int *p0 = arr;
    
    fun(p0);
}

形参和实参都用数组名；
实参用数组名，形参用指针变量；

实参形参都用指针变量

void fun(int *p1){}
void main()
{
    // 注意：如果实参和形参都是指针，我们的实参需要初始化
    int arr[2] = {23,34};
    int *p0 = arr;
    
    fun(p0);
}

实参为指针变量，形参为数组名

举例：将数组ａ中n个整数按相反顺序存放

/**
 * 需求：将数组ａ中n个整数按相反顺序存放。
 */
#include <stdio.h>
/* 数组的反转：数组实现*/
void inv(int arr[],int len)
{
    // 反转思路：将第0个和n-1个进行对掉，将第1个和n-2个对掉..
    
    // 定义循环变量i，临时变量temp
    int i = 0,temp;
    // 遍历数组
    for(;i < len/2;i++)
   {
        // 交换
        temp = arr[i];
        arr[i] = arr[len-1-i];
        arr[len-1-i] = temp;
   }
}
/* 
  数组的反转：指针实现
  关键字：const 给变量的数据类型前面添加const，代表这个变量是只读变量，无法对此作出修改
*/
void inv2(int *arr,const int len)
{
    // 反转思路：将第0个和n-1个进行对掉，将第1个和n-2个对掉..
    
    // 定义循环变量i，临时变量temp *j = &arr[len -1] 等价于 arr + len -1
    int *i = arr,*j = &arr[len-1],temp;
    // 遍历数组
    for(;i < j;i++,j--)
   {
        // 交换
        temp = *i;
        *i = *j;
        *j = temp;
   }
}
int main()
{
    int array[10] = {12,23,45,55,66,77,88,26,34,32};
    int len = sizeof(array)/sizeof(int);
    inv2(array,len);
    // 测试是否反转
    for(int i = 0;i < len;i++) printf("%d,",array[i]);
    
    printf("\n");
    
    return 0;
}

七、数组指针（先有数组，后有指针）

数组指针：指向一维数组的指针变量。（指向的是一个完整的数组）

数组指针定义：假定该指针变量指向具有N个元素的一维数组，则数组指针变量定义如下：

数据类型 (*数组指针变量名)[N];

一维数组：

int a[N] = {1,2,3};
int (*p)[N] = &a;

举例：指向数组的指针

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

二维数组：

int a[][N] = {1,3,5,7};
int (*p)[N] = a[0];// &a[0][0]

分析：

int arr[3] = {1,2,3};
int *p = arr;// &arr[0] 首地址：第1个元素的首地址
int (*p)[3] = &arr;
// p = &arr[0];
int arr[][3] = {1,2,3,4,5,6};
int *p = arr[0]; // &arr[0][0] 首地址：第1行第1列元素的首地址
int (*p)[3] = &arr[0];
// p = &arr[0][0]

举例：用指向元素的指针变量输出二维数组元素的值

/**
 * 数组指针： 用指向元素的指针变量输出二维数组元素的值
 */
#include <stdio.h>
int main()
{
    // 定义一个普通的二位数组
    int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23};
    int *p = &a[0][0];// 二维数组 等价于 a[0]
    // 循环遍历
    for(;p < a[0]+12;p++)
   {
        if((p - a[0]) % 4 == 0)
       {
            printf("\n");
       }
        printf("%4d",*p);
   }
    printf("\n");
    return 0;
}

举例：输出二维数组任一行任一列元素的值

/**
 * 数组指针：输出二维数组任一行任一列元素的值。
             此时：我们需要将二维数组看作是一个特殊的一维数组
 */
#include <stdio.h>
int main()
{
    int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23};
    int (*p)[4]; // 我们把行使用指针表示
    
    p = &a[0]; // 等价于 p = a
    int i,j;// 代表我们要显示的数据对应的行号和列号
    printf("请输入行号和列号：\n");
   
    scanf("i=%d,j=%d",&i,&j);
    printf("a[%d][%d]=%d\n",i,j,*(*(p+i)+j));
    return 0;
   
    
}

举例：二维数组指针案例

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

建议：我们一般使用指针数组处理字符串。

九、字符串指针

1、字符串实现

在C语言中，表示一个字符串有以下两种形式：

用字符数组存放一个字符串；
用字符指针指向一个字符串。

举例：字符串的两种实现方式

/**
 * 字符串的两种实现方式
 */
#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;
}

注意：字符数组和字符指针变量都能实现字符串的存储与运算。

2、字符数组和字符指针的联系

字符数组由元素组成，每个元素中存放一个字符，而字符指针变量中存放的是地址，也能作为函数参数；
只能对字符数组中的各个元素赋值，而不能用赋值语句对整个字符数组赋值；
字符数组名虽然代表地址，但数组名的值不能改变。因为数组名是常量；
对于字符串中字符的存取，可以用下标法，也可以用指针法。

举例：字符数组和字符指针的关系

/**
 * 字符数组和字符指针的联系
 */
#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;
}

3、字符串指针作为形式参数

实参与形参都可以是字符参数；
实参用字符数组，形参用字符指针（在函数内部不能对字符串中的字符做修改）

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

实参是指针类型，形参是字符数组

注意：
字符数组在创建的时候，会在内存中开辟内存空间，内存空间可以存放字符数据；字符指针在创建的时候，需要依赖于字符数组，字符指针在内存中开辟的内存空间中，存放的是数组元素的内存地址。字符指针的创建依赖于字符数组，字符数组可以独立存在，而字符指针不能独立存在；
字符数组可以初始化，但是不能赋值；字符指针可以初始化，也可以赋值。
// 字符数组
char str1[11] = "I love You!";
str1 = "Home"; // 错误
str1[] = "home"; // 错误
// 字符指针
char *str2 = "I love You!";
str2 = "home";// 正确

举例：字符指针作为函数参数：用函数调用实现字符串，复制以及计算字符串长度。

/**
 * 字符指针作为函数参数：用函数调用实现字符串，复制以及计算字符串长度。
 */
#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;
    
}

举例：给定一个字符串，截取start到end之间字符串，含头不含尾

/**
 * 给定一个字符串，截取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、函数指针

1.定义：函数指针本质是指针，它是函数的指针（定义一个指针变量，变量中存储了函数的地址）。函数都有一个入口地址，所谓指向函数的指针，就是指向函数的入口地址。这里函数名就代表入口地址。

2.函数指针存在的意义：

让函数多了一种调用方式；
函数指针作为形参，可以形式调用（回调函数）

3.定义格式：

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

举例：

int (*p) (int a,int b);

4.函数指针的初始化

定义同时赋值

// 得先有函数，才能定义这个函数的指针
int fun(int a,int b){..}
// 定义函数指针并给它赋值
int (*p) (int a,int b) = fun;// fun不能跟()

先定义后赋值

// 得先有函数，才能定义这个函数的指针
float fun(int a,double b,char c){..}
// 先定义函数指针
float (*p) (int a,double b,char c);
// 赋值
p = fun;

总结：

函数指针指向的函数要和函数指针定义的返回值类型，形参列表对应，否则编译报错；
函数指针是指针，但不能指针运算，如p++等，没有实际意义；
函数指针作为形参，可以形成回调（回调后面讲）；
函数指针作为形参，函数调用时的实参只能是与之对应的函数名，不能带小括号；
函数指针的形参列表中的变量名可以省略。

举例：求a，b两个数的最大值

/**
 * 函数指针：指向函数的指针变量就是函数指针
       需求：求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;
}

2、指针函数

1.定义：本质是函数，这个函数的返回值类型是指针，这个函数成为指针函数。

2.定义格式：

指针类型 函数名(形参列表)
{
    函数体;
    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;
}

十一、野指针、空指针

1、野指针

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

2.野指针产生的场景：

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

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

指针变量未初始化

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

指针指向的内存空间被（free函数）回收了——后面讲；
指针函数中直接返回了局部变量的地址；
指针指向数组以外的地址（下标越界）。

3.如何避免野指针：

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

指针变量要及时初始化，如果暂时没有对应的值，建议赋值为NULL；
数组操作（遍历，指针运算）时，注意数组的长度，避免越界；

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

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

指针变量使用之前要检查他的有效性（以后开发中要做非空校验）
```
int *p = NULL;
if(!p)//非空校验
{
    return -1;
}
```

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

2、空指针

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

十二、二级指针

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

int a = 10;
int *p = &a;
int **w = &p;//二级指针

2、定义格式：

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

//指针数组
int array = {1,2,3};
int *arr = (&array[0],&array[1],&array[2]);//指针数组

//一级指针
int a = 10;
int *p = &a;//一级指针

3、举例：

// 字符型指针数组
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;//正确，二级指针的地址

4、结论

二级指针和指针数组是等效的，和二维数组不等效；
二维数组和数组指针是等效,和二级指针不等效；

5、二级指针的用法：

如果是字符的二级指针，可以像遍历字符串数组一样遍历他；
如果是其他的二级指针，就需要解引用两次访问它所指向的数据。

举例：二级指针案例：使用指向指针数据的指针变量

/**
 * 二级指针案例：使用指向指针数据的指针变量。
 */
#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){}
...

说明：

argc，argv是形参的名称，它们俩可以修改；
main函数的扩展写法有些编译器不支持，编译报警告；
argc和argv的常规写法：
a. argc：存储了参数的个数;

b. argv：存储了所有参数的字符串形式
main函数是系统通过函数指针的回调形式调用的

注意：如果一个函数没有写返回值类型，这个函数的默认返回类型是int

举例：main函数

/**
 * 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;//编译错误，因为此时这个变量是只读常量，所以不可更改其值

1、常量指针

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

定义格式：

const 数据类型 *变量名；

举例：

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

结论：

常量指针指向的数据不能被改变（不能解引用间接修改数据）；
常量指针的地址可以改变

应用场景：作为形式参数，实际参数需要给一个常量。

举例：常量指针

#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();
}

2、指针常量

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

定义格式：

数据类型* const 变量名；

举例：

int* const p;//指针常量

结论：

指针常量的指向不能被改变（不能给指针变量重新赋地址值）；
指针常量指向的数据可以被改变；

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

举例：常量指针与指针常量

/**
 * 常量指针与指针常量
 */
#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();
}

3、常量指针常量

定义语法：

const 数据类型* const 变量名；

举例：

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

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

十五、动态内存分配

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

函数所属的库文件；
函数的原型 - 函数的声明

函数名；
形参；
返回值类型。

函数的功能。

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

1、常用函数

malloc

头文件：#include <stdlib.h>
函数功能：C库函数 void *malloc(size_t size)分配所需的内存空间，并返回一个指向它的指针。
函数原型：

函数名：malloc
形参：size_t size：内存块的大小，以字节为单位。本质上就是一个 unsigned int ;
返回值类型： void* :该函数返回一个指针，指向已分配大小的内存，如果请求失败，返回NULL。

举例：
```
int *p = (int*)malloc(4);
```
说明：

malloc函数分配的内存没有默认值，是不确定数，大概率是0；
malloc函数申请的内存空间连续。

calloc

头文件： #include <stdlib.h>
函数功能：C库函数 void * calloc(size_t nitems,size_t size)分配所需的内存空间，并返回一个指向它的指针。

malloc和calloc之间不同的是，malloc不会设置内存为零，calloc会设置内存为零。

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

函数名：calloc
形式参数：
1）size_t nitems：申请多少个；

2）size_t size：一个占几个内存单元（一个内存单元等于一个字节）
返回值类型：void*: 该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL。

举例：

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

说明：

calloc函数分配的内存有默认值，每个内存单元都是0；
calloc函数申请的内存空间连续；
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("\n");

//p使用完，记得释放内存
free(p);
p = NULL;//内存回收后，建议置空

realloc

头文件： #include <stdlib.h>
函数功能：尝试重新调整之前调用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)

说明：

realloc以原来malloc返回的内存地址开始，分配总共20个字节的内存空间；
如果原来的内存空间后有20个连续空间，就扩容20-4 =16个内存单元，返回原来旧的内存首地址；
如果原来的内存空间后不够20个连续内存空间，就重新找一个内存地址开始，申请20个内存单元。并将原来的数据拷贝到新的内存中，回收旧的内存单元，并返回新的内存首地址。

free

头文件： #include <stdlib.h>
函数功能：释放之前调用 malloc、calloc、realloc所分配的内存空间，是访问完记得使用NULL置空。
函数原型： void free(void *ptr)
函数名：free
形式参数：

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

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

注意：

堆内存中的指针才需要回收，栈中系统会自动回收；
堆内存不能重复回收，运行会报错。

说明：

堆的内存空间相比较栈要大很多；
内存分配函数返回的指针变量可以参与运算（只读），但不能被修改（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;
}

十七、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*在间接访问（解引用）前要强制类型转换，但不能太随意，否则存和去的数据类型不一致。

十八、函数的传参

值传递：一般发生在函数形参的类型为char、short、int、long、float、double这样的类型，它的传递，一般是实参将自己的值复制一份给形参，也就是实参变量和形参变量的变量空间是分开的。此时形参无法改变实参的数据；
引用传递：一般发生在函数形参的类型为数组、指针这样的类型，它的传递，一般是实参将自己的内存首地址复制一份给形参，也就是实参变量和形参变量对应内存空间是同一个。此时形参可以改变实参的数据。

十九、内存操作

我们对于内存的操作借助于 string.h 这个库提供的内存操作函数。

1、内存填充

头文件： #include <string.h>
函数原型： void *memset(void *s,int c,size_t n);
函数功能：填充s开始的堆内存空间前n个字节，使得每个字节值为c
函数参数：

void *s：待操作内存首地址；
int c：填充的字节数据；
size_t n：填充的字节数；

返回值：返回s

注意：c常常设置为0，用于动态内存初始化。

举例：内存操作函数-memset

 /**
* 内存操作函数-memset
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void test1()
{
    //在堆内存申请了一块存储空间
    int *p = (int*)malloc(4 * sizeof(int));
    if(!p)
    {
        puts("内存分配失败！");
        return;//后续代码不需要执行
    }

    //给这块内存进行初始化操作（填充）
    memset(p,0,4 * sizeof(int));

    printf("%d\n",*(p+1));

    //内存使用完毕进行回收
    free(p);
    p = NULL;
}

int main()
{
    test1();

    return 0;
}

2、内存拷贝（相当于替换，不是复制）

头文件：#include <string.h>
函数原型：void *memcpy(void *dest,const void *src,size_t n)；适合目标地址与源地址内存无重叠的情况；void *memmove(void *dest,const void *src,size_t n);
函数功能：拷贝src开始的堆内存空间前n个字节，到dest对应的内存中；
函数参数：

void *dest：目标内存首地址；
void *src：源内存首地址；
size_t n：拷贝的字节数。

返回值：返回dest；
注意：内存申请了几个内存空间，就访问几个内存空间，否则数据不安全；
注意：memcpy和memmove一般情况下是一样的，更建议使用memmove进行内存拷贝；因为memmove函数是从自适应（从后往前或从前往后）拷贝，当被拷贝的内存和目的地的内存有重叠时，数据不会出现拷贝错误；memcpy函数是从前往后拷贝，当被拷贝的内存和目的地的内存有重叠时，数据会出现拷贝错误；

举例：内存操作函数-memcpy / memmove

 /**
 * 内存操作函数-memcpy|memmove
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test1()
{
    // 申请内存
    // int *p1 = (int*)malloc(4 * sizeof(int));
    // int *p2 = (int*)malloc(6 * sizeof(int));
    
    // 给p1,p2填充数据，可以使用for循环..
    // for(int i = 0; i < 4; i++)
    //   p1[i] = 10 + i;
    
    // memset(p2,0,6 * sizeof(int));   
    // 创建数组
    int p1[4] = {11,12,13,14};
    int p2[6] = {21,22,23,24,25,26};
    // 将p1中的数据通过内存拷贝函数，拷贝到p2
    // memcpy(p2+2,p1+1,2*sizeof(int))   // int p2[6] = {21,22,12,13,25,26}
    memmove(p2+2,p1+1,2*sizeof(int));
    // 测试输出数组
    for(int i = 0; i < 4; i++)
        printf("%4d",p1[i]);
    printf("\n");
    for(int j = 0; j < 6; j++)
        printf("%4d",p2[j]);
    printf("\n");
    // 如果使用手动分配的指针，一定要记得释放内存
    // free(p1);
    // free(p2);
    // p1 = NULL;
    // p2 = NULL;
}
int main()
{
    test1();
    return 0;
}

3、内存比较

头文件： #include <string.h>
函数原型： int memcmp(void *dest,const void *src,size_t n)
函数功能：比较src和dest所代表的内存前n个字节的数据；
函数参数：

void *dest：目标内存首地址;
const void* src：源内存首地址;
size_t n：比较的字节数

返回值：

0：数据相同;
>0 ：dest中的数据大于src;
<0：dest中的数据小于src.

注意：n一般和src，dest的总容量一样；如果不一样，内促比较的结果就不确定了。

举例：内存操作-memcmp

/**
 * 内存操作-memcmp
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test1()
{
    // 申请内存
    int *p1 = (int*)malloc(3*sizeof(int));
    int *p2 = (int*)malloc(4*sizeof(int));
    // int p1[4] = {1,0,3,6};
    // int p2[4] = {1,2,3,4};
    // int result = memcmp(p1,p2,4*sizeof(int));
    *p1 = 65;
    *p2 = 70;
    char *a = (char*)p1;// 类型转换
    char *b = (char*)p2;
    printf("%c,%c\n",*a,*b);
    
    int result = memcmp(a+1,b+1,1*sizeof(char));
    printf("%d\n",result);   
}
int main()
{
    test1();
}

4、内存查找

头文件： #include <string.h>
函数原型： int *memchr|*memrchr(const void *s,int c,size_t n)
函数功能：在s开始的堆内存空间前n个字节中查找字节数据c
函数参数：

const void *s：待操作内存首地址；
int c：待查找的字节数据;
size_t n：查找的字节数;

返回值：返回查找到的字节数据地址

注意：如果内存中没有重复数据，memchr和memrchr结果是一样的；如果内存中有重复数据， memchr和memrchr结果就不一样；

举例：

void *memrchr(..);// 在使用时编译会报错，需要使用外部声明
// 外部申请
extern void *memrchr(..);

举例：内存操作-memchr / memchr

/**
 * 内存操作-memchr | memrchr
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 声明外部函数
extern void *memrchr(const void *s,int c,size_t n);
void test1()
{
    // 申请内存
    int *p = (int*)malloc(4*sizeof(int));
    if(!p)
   {
        puts("内存分配失败！");
        return;
   }
    // 给变量赋值
    for(int i = 0; i < 4; i++)
   {
        p[i] = i * 2;
   }
    p[3] = 4;
    
    // 输出
    for(int i = 0; i < 4; i++)
   {
        printf("%d,",p[i]);
   }
    printf("\n");
    // 内存查找 memchr
    int *x = (int*)memchr(p,4,4*sizeof(int));
    printf("%p--%p--%d\n",x,p,*x);
    // 内存查找 memrchr
    int *y = (int*)memrchr(p,4,4*sizeof(int));
    printf("%p--%p--%d\n",y,p,*y);
    // 回收内存
    free(p);
    p = NULL;
}
int main()
{
    test1();
}

二十、作业

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

代码：

 /**
* 利用指针变量将一个数组中的数据反向输出;
*/
#include <stdio.h>

void rev(int *arr,const int len)
{
    int *i = arr,*j = &arr[len - 1],t;//定义变量

    for(;i < j;i++,j--)//遍历，反向输出，交换数据
    {
        t = *i;
        *i = *j;
        *j = t;
    }
}

int main()
{
    int i = 0;
    int arr[3] = {1,2,3};//定义数组中的数据
    int len = sizeof(arr) / sizeof(int);//计算长度

    for(i = 0;i < len; i++)//遍历，正向输出数组
    {
        printf("您所输入的数组中的数据为：%3d\n",arr[i]);
    }
    printf("\n");

    rev(arr,len);//引用自定义函数

    for(int i = 0;i < len;i++)//遍历，输出反向后的数据
    {
        printf("反向输出的数据为%3d\n",arr[i]);
    }

    return 0;
}

运行效果：

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

代码：

 /**
* 利用指针变量计算下标为奇数的数组的和;
*/
#include <stdio.h>
#include <math.h>

int main()
{
    int arr[8] = {11,22,33,44,55,66,77,88};//定义数组
    int len = sizeof(arr) / sizeof(int);
    int (*p)[8] = &arr;//创建指针变量
    int sum = 0;
    int i = 0;

    for(int i = 0;i < len;i++)
    {
        if(i % 2 != 0)
        {
            printf("您定义的数组中下标为奇数的数为：%d\n",(*p)[i]);
            sum += (*p)[i];
        }
    }

//    printf("您定义的数组中下标为奇数的数为：%d\n",(*p)[i]);
    printf("您定义的数组中下标为奇数的数组的和为：%d\n",sum);

    return 0;
}

运行效果：

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

代码：

 /**
* 确认整型，字符型，浮点型指针变量的大小;
*/
#include <stdio.h>

int main()
{
    int *intVariable;
    char *charVariable;
    float *floatVariable;
    double *doubleVariable;

    printf("整型指针变量的大小为：%zu byte\n",sizeof(intVariable));
    printf("字符型指针变量的大小为：%zu byte\n",sizeof(charVariable));
    printf("单精度浮点型指针变量的大小为：%zu byte\n",sizeof(floatVariable));
    printf("双精度浮点型指针变量的大小为：%zu bbyte\n",sizeof(doubleVariable));

    return 0;
}

运行效果：

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

代码：

 /**
* 利用指针变量输出字符数组中的所有字符;
*/
#include <stdio.h>

int main()
{

    char arr[11] = "we are one!";//定义数组
    int len = sizeof arr / sizeof arr[0];//计算数组中的元素个数
    char *p = arr;//创建指针变量

    register int i = 0;//创建循环变量

    for(;i < len;i++)//遍历
    {
        printf("%c\n",*(p+i));
    }
    printf("\n");
    return 0;
}

运行效果：

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

代码：

 /**
* 编写一个函数，用指针变量做参数，用于求出一个浮点型数组元素的平均值
*/
#include <stdio.h>
#include <math.h>

float calcuAve(float *a,int len)
{
    float sum = 0.0;
    float aver = 0.0;

    for(int i = 0;i < len;i++)
    {
        sum += *(a+i);
    }
    aver = sum / len;
    return aver;
}

int main()
{
    float arr[3] = {1.3,5.4,4.8};
    int len = sizeof(arr) / sizeof(arr[0]);
    float sum = 0.0,aver = 0.0;
    aver = calcuAve(arr,len);
    printf("您所输入的数组的数据的均值为：aver = %f\n",aver);

    return 0;
}

运行效果：

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

（1）求一个字符串长度

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

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

代码：

 /**
* 编写函数,要求用指针做形参，分别实现以下功能：
（1）求一个字符串长度
（2）在一个字符串中统计大写字母的个数
（3）在一个字符串中统计数字字符的个数
*/
#include <stdio.h>
#include <string.h>

//定义求字符串长度函数
int fun_long(char *a)
{
    unsigned long lo = strlen(a);
    printf("您所输入的字符串的长度为：%lu\n",lo);

    return 0;
}

//定义求大写字母个数的函数
int fun_findCapsLett(char *a)
{
    int lett = 0;//初始化

    while(*a != '\0')
    {
        if(*a <= 'Z' && *a >= 'A')
        {
            lett++;
        }
        a++;
    }


    printf("您所输入的字符串中大写字母的个数为：%d\n",lett);

    return lett;
}


//定义求数字字符的个数
int fun_findNumbers(char *a)
{
    int num = 0;

    while(*a != '\0')
    {
        if(*a <= '9' && *a >= '0')
        {
            num++;
        }
        a++;
    }

    printf("您所输入的字符串中数字字符的个数为：%d\n",num);

    return num;
}

int main()
{
    //定义字符串，输出字符串
    char slogan[] = "1 2 3 We Are One!";
    printf("您所输入的字符串为：%s\n",slogan);
    //输出字符串长度
    fun_long(slogan);

    //定义字符串长度
    int len = sizeof(slogan) / sizeof(slogan[0]);

    //输出大写字母个数
    fun_findCapsLett(slogan);

    //输出数字字符个数
    fun_findNumbers(slogan);

    return 0;
}

运行效果：

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

代码：

 /**
 * 需求：编写函数,要求用指针做形参，实现将二维数组(行列相同)的进行转置（行列数据互换）
 */
#include <stdio.h>

/**
 * 数组转置
 */
void transpose(int rows, int cols, int (*arr)[cols]) {
    int temp;
    for (int i = 0; i < rows; i++) {
        for (int j = i + 1; j < cols; j++) {
            temp = arr[i][j];
            arr[i][j] = arr[j][i];
            arr[j][i] = temp;
        }
    }
}

int main() {
    // 定义一个二位数组
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    printf("原数组：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    // 数组转置
    transpose(3, 3, arr);

    printf("转置后的数组：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

运行效果：

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

代码：

 /**
* 编写函数，要求用指针做形参，实现统计二维数组上三角中的0的数量
*/
#include <stdio.h>

int statistics(int *arr,int rows,int cols)
{
    int num = 0;
    for(int i = 0;i < rows;i++)
    {
        for(int j = i;j < cols;j++)
        {
            if(*(arr + i * cols + j) == 0)
            {
                num++;
            }
        }
    }
    return num;
}

int main()
{
    //定义一个二维数组
    int arr[3][3] = {{1,2,0},{4,0,6},{7,8,0}};
    int num = 0;

    printf("原数组：\n");
    for(int i = 0;i < 3;i++)\
    {
        for(int j = 0;j < 3;j++)
        {
            printf("%d",arr[i][j]);
        }
        printf("\n");
    }

    int i,j;

    //统计上三角中0的个数
    num = statistics(&arr[0][0],3,3);

    printf("二维数组中上三角中的0的数量为：%d\n",num);

    return 0;
}

运行效果：

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

代码：

 /**
* 编写一个指针函数，返回二维数组中最大元素的地址
*/
#include <stdio.h>
//#include <string>

int address(int *arr,int rows,int cols)
{
//    int max = &arr[0][0];
    int max;
    for(int i = 0;i < rows;i++)
    {
        for(int j = 0;j < cols;j++)
        {
            if(*(arr + i*cols + j) > max)
            {
                max = *(arr + i*cols + j);

            }
        }
    }
    return max;
}

int main()
{
    //定义一个二维数组
    int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
//    int max = 0;

    printf("定义的二维数组为：\n");
    for(int i = 0;i < 3;i++)
    {
        for(int j = 0;j < 3;j++)
        {
            printf("%3d",arr[i][j]);
        }
        printf("\n");
    }

    int i,j;

    int max = address(&arr[0][0],3,3);


//    printf("二维数组中最大元素 %d 的地址为：%p\n",*max,(int*)max);
    printf("%d,%p\n",max,(int*)max);

    return 0;
}

运行效果：

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;