其他分享
首页 > 其他分享> > 嵌入式学习DAY9 --- const修饰的指针 ,函数 ,函数的声明 ,指针作为参数传参 ,一维和二维数组的传参

嵌入式学习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