标签：传参 const 函数 int pArr printf return 指针
嵌入式入门学习笔记，遇到的问题以及心得体会！
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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。