嵌入式☞第二组（伍，补充）

C语言基础：

数组指针与指针数组

数组指针

• 概念：数组指针是指向数组的指针

• 特点：

• 先有数组，后有指针。

• 它指向的是一个完整的数组。

• 一维数组指针：

• 语法：

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

• 案例

/**
* 数组指针：指向数组的指针
*/
#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);
      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 变量名

举例：

int* const p; // 指针常量

• 结论：

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. 函数的原型-函数的声明

3. 函数名

4. 形参

5. 返回值类型

6. 函数的功能

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

### 常用函数

**malloc**

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

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

- 举例：

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

- 说明：

1. malloc函数分配的内存没有默认值，是不确定数，大概率是0；
2. 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
- 形式参数：
- size_t nitems：申请多少个
- size_t size：一个占几个内存单元（一个内存单元 等于 一个字节）
- 返回值类型：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL。
- 举例:

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

- 说明：

1. calloc函数分配的内存有默认值，每个内存单元都是0
2. calloc函数申请的内存空间连续
3. calloc大多时候为数组中的元素申请内存
  转存栈中数组中的数据：

```c
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 <stdlib.h>`
- 函数功能：尝试重新调整之前调用`malloc或calloc`所分配的`ptr`所指向的内存块的大小。
- 函数原型：` void *realloc(void *ptr,size_t size)`

- 函数名：realloc
- 形式参数：
- void *ptr：是malloc或者calloc的返回值
- size_t size：重新分配后的内存大小
- 返回值：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL。
- 案例：

```c
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 <stdlib.h>

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

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

• 函数名：free

• 形式参数：

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

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

• 注意：

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

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

说明：

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

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