嵌入式学习DAY9 --- const修饰的指针 ,函数 ,函数的声明 ,指针作为参数传参 ,一维和二维数组的传参
作者：互联网
嵌入式入门学习笔记，遇到的问题以及心得体会！
DAY9
概述：
1，const修饰的指针
2，函数
3，函数的声明
4，指针作为参数传参
5，一维和二维数组的传参
笔记：
1，const修饰的指针
int a = 90;
a = 100;
printf(“a = %d\n”,a);//100
const int a = 90;
a = 100;
总结：
1，被const 修饰的变量的存储位置并不会迁移到常量区，原来在哪里，现在依然在哪里，只是被常量化了
2，const 修饰谁，谁就不能被更改，没有修饰谁，谁就可以被更改
代码演示const修饰
#include <stdio.h>
int main(int argc, const char *argv[])
{
/* const int a = 10;
//a = 100;
int *p = (int *)&a;
*p = 66;
printf("a = %d\n",a);
*/
char *pStr = "wangjia";
*pStr = 'K';
return 0;
}
const 修饰的指针分类：
（1）指向常量的指针：
const int p;//代表p即该指针所指向空间的内容不能被更改，但是可以更改p的指向，以及通过a去修改a的值
int const *p;
（2）指针常量
int const p;//代表p的指向不能被更改，但是可以通过p和a去修改值
验证const修饰指针分类
#include <stdio.h>
int main(int argc, const char *argv[])
{
//验证指向常量的指针
/*int a = 90;
const int *p = &a;
*p = 100;
//int b = 80;
// main(int argc, const char *argv[])
{
//验证指向常量的指针
/*int a = 90;
const int *p = &a;
*p = 100;
//int b = 80;
//p = &b;
a = 80;*/
//验证指针常量
int a = 90;
int b = 79;
p = &b;
a = 80;*/
//验证指针常量
int a = 90;
int b = 79;
int *const p = &a;
//p = NULL;
//*p = 190;
//printf("a = %d\n",a);
a = 77;
printf("a = %d\n",a);
return 0;
}
2，函数：为了实现一个独立的功能，提高代码的复用率
函数的分类：
（1）库函数：系统已经封装好很多的接口函数，只需要调用者正确传参即可
（2）自定义函数：程序员自己定义的函数接口，用于实现特定的功能
函数定义格式：
返回值类型1 函数名(数据类型2 形参名1，数据类型3 形参名2…)
{
函数体；//代码的实现过程
返回值；//注意：函数的返回值应该和返回值类型保持一致
}
分析：
返回值：需要反馈给调用者的一个结果。
函数名：一般见名知义。
数据类型2：就是调用者传递给子函数的参数的类型。
练习：自己声明一个函数初步认识
#include <stdio.h>
//函数的声明
int cal_add(int num1,int num2);
//定义一个函数：实现打印“哈哈哈哈哈”;
void print_haha()
{
//函数体
printf("hahahahha\n");
printf("hahahahha\n");
printf("hahahahha\n");
}
int func(int value)
{
printf("fun-----%d\n",value);
return value;
}
int main(int argc, const char *argv[])
{
//调用字函数实现打印
/*print_haha();
* */
int num1,num2;
printf("please input two numbers:\n");
scanf("%d%d",&num1,&num2);
//封装字函数实现两个数求和
int sum = cal_add(num1,num2,12,34,56);
printf("sum = %d\n",sum);
//printf("%d\n",cal_add(num1,num2));
//int value = 6;
//printf("%d\n",func(value));
//func(34);
//func(value*value);
return 0;
}
//封装加法函数
int cal_add(int num1,int num2)
{
return num1 + num2;
}
总结：
1，函数在传参时，参数个数和类型应该和形参类型以及个数保持一致
2，实参名和形参名可以重名，因为形参和实参是两块独立的内存空间
3，函数传参时可以传变量，常量，或者表达式（只要是一个确定的值就行）
4，当需要在子函数中修改形参值的同时起到修改实参的值，就需要将实参的地址作为参数传递给形参
传参的方式：
（1）值传递
（2）址传递
练习：
1.声明一个函数，调用来交换两个数据
#include <stdio.h>
void swap(int *A,int *B)
{
//交换
int Temp;
Temp = *A;
*A = *B;
*B = Temp;
}
int main(int argc, const char *argv[])
{
//实现两个数的交换
int num1,num2;
scanf("%d%d",&num1,&num2);
printf("交换之前: num1 = %d\tnum2 = %d\n",num1,num2);
swap(&num1,&num2);
printf("交换之后: num1 = %d\tnum2 = %d\n",num1,num2);
return 0;
}
2.写一个函数用来调用两数相加和
#include <stdio.h>
void add(int *argc1,int *argc2,int *pSum)
{
*pSum = *argc1 + *argc2;
}
int main(int argc, const char *argv[])
{
int num1,num2;
scanf("%d%d",&num1,&num2);
int value = 0;
add(&num1,&num2,&value);
printf("value = %d\n",value);
return 0;
}
注：这里两个联系题代码声明的函数都是无返回值的，且形参会将实参中的数据拷贝过去，进行交换时其实只交换了形参中的数据，程序运行出来的结果还是没有交换，为了避免这种问题采用指针方法，将地址传过去通过地址改变数据。
3，函数的声明
作用：帮助编译器进行语法检查（检查实参的个数和类型是否与形参的个数以及类型相匹配）
写法：直接拷贝函数头，在其末尾添加分号即可
4，指针作为参数传参
案例：封装子函数实现两个整形数的交换
5，一维数组的传参
数组的传参：
操作数组相当于是在操作一片连续的空间
操作连续空间的要素：
（1）什么时候开始—》首地址
（2）什么时候结束—》元素个数
对于一维数组的传参：
//int Input_arrValues(int *pArr)
int Input_arrValues(int pArr[])
//int Output_arrValues(int *pArr)
int Output_arrValues(int pArr[])
注意：当数组作为参数进行传参时，会被退化成一个指针来使用，这里的[]其实就是一个*
练习：
一维数组输入输出封装函数练习
#include <stdio.h>
#define N 5
//int Input_arrValues(int *pArr)
int Input_arrValues(int pArr[])
{
printf("sizeof(pArr) = %d\n",sizeof(pArr));
//入参检查
if(NULL == pArr)
{
printf("NULL_IN_ERROR!\n");
return -1;
}
int i;
for(i=0;i<N;i++)
{
scanf("%d",&pArr[i]);
//scanf("%d",pArr+i);
}
return 0;
}
//int Output_arrValues(int *pArr)
int Output_arrValues(int pArr[])
{
//检查
if(NULL == pArr)
{
printf("NULL_OUT_ERROR!\n");
return -1;
}
int i;
for(i=0;i<N;i++)
{
printf("%d ",pArr[i]);
//printf("%d ",*(pArr+i));
}
printf("\n");
return 0;
}
int main(int argc, const char *argv[])
{
//封装函数实现一维数组的输入和输出
int arr[N] = {0};
printf("sizeof(arr) = %d\n",sizeof(arr));
//输入
int op = Input_arrValues(arr);
if(-1 == op)
{
return -1;
}
printf("输入成功!\n");
//输出
op = Output_arrValues(arr);
if(-1 == op)
{
return -1;
}
printf("输出成功!\n");
return 0;
}
二维数组的传参：
//int Input_Arr_Values(int (*pArr)[N])
int Input_Arr_Values(int pArr[][N])
//int Output_Arr_Values(int (*pArr)[N])
int Output_Arr_Values(int pArr[][N])
练习：
二维数组输入输出封装函数练习
#include <stdio.h>
#define M 3
#define N 4
//int Input_Arr_Values(int (*pArr)[N])
int Input_Arr_Values(int pArr[][N])
{
//入参检查
if(NULL == pArr)
{
printf("NULL_IN_ERROR!\n");
return -1;
}
int i,j;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
//scanf("%d",*(pArr+i)+j);
//scanf("%d",&pArr[i][j]);
scanf("%d",pArr[i]+j);
}
}
return 0;
}
//int Output_Arr_Values(int (*pArr)[N])
int Output_Arr_Values(int pArr[][N])
{
//入参检查
if(NULL == pArr)
{
printf("NULL_OUT_ERROR!\n");
return -1;
}
int i,j;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
//printf("%d ",*(*(pArr+i)+j));
//printf("%d ",pArr[i][j]);
printf("%d ",*(pArr[i]+j));
}
printf("\n");
}
return 0;
}
int main(int argc, const char *argv[])
{
//封装函数实现二维数组的输入输出
int arr[M][N] = {0};
//输入
int op = Input_Arr_Values(arr);
if(-1 == op)
{
return -1;
}
printf("输入成功!\n");
//输出
op = Output_Arr_Values(arr);
if(-1 == op)
{
return -1;
}
printf("输出成功!\n");
return 0;
}
作业：
利用函数封装实现之前的作业（都尝试去封装（一维，二维））；
标签：传参,const,函数,int,pArr,printf,return,指针 来源： https://blog.csdn.net/SpringWJN/article/details/114374931