嵌入式初学-C语言-二三

多重指针

定义：

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

语法：

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

// 指针数组
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的常规写法
4.  argc：存储了参数的个数
5. argv：存储了所有参数的字符串形
6. 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]);
}

常量指针与指针常量

常量：分为字面量（平时直接操作的如priintf（12））printf（“hellow”）和只读常量使用关键字（const）修饰，凡是被这个关键字修饰的变量，一旦复制，值就不能改变

语法：

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

常量指针

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

语法：const 数据类型 *变量名

结论：

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 变量名

作用：p的指向不能被改动（地址），p指向的数据也不能被改动

动态内存分配

我们想要事项动态内存分配，就要学习标准c提供的函数库

1. 函数所属库文件
2. 函数的原型-函数的声明

1. 函数名
2. 形参
3. 返回值类型 
4. 返回值类型

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

mlloc

       头文件：#include <stdlib.h>

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

函数原型：

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

 举例：

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不会设置内存为0，而calloc会设置内存为0

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

1. 函数名：calloc
2. 形式参数：size_t nitems:申请多少个

  size_t size：一个站几个内存单元（一个内存单元=一个字节）

1. 返回值类型：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 <stdlib.h>

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

函数类型：void * realloc (void *ptr，size_t size)

1. 函数名：realloc
2. 形式参数：

Void*ptr:是malloc或calloc的返回值

Size_t size：重新分配内存大小

       3． 返回值：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 <stdlib.h>

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

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

1. 函数名：free
2. 形式参数：

void*ptr：malloc，calloc，realloc的返回值

1. 返回值类型：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;
}