Day 10-11：函数、函数传参

基本用法以及传参

基本用法

调用

        1.无返回值函数调用

#include<stdio.h>
#pragma warning(disable:4996);
void my_helloworld()
{
	printf("hello world!");
}
int main()
{
	my_helloworld();
	return 0;
}
//输出结果：hello world！

        2.实际参数：就是在使用函数时，调用函数传递给被调用函数的数据。

        应用：编写一个函数，求两个整数的最大值，并在main函数中调用。

#include<stdio.h>
#pragma warning(disable:4996);
int find_max(int x, int y)//x、y是形式参数
{
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d", &a);
	getchar();
	scanf("%d", &b);
	int ret = find_max(a, b);//a、b是实际参数
	printf("最大值：%d\n", ret);
	return 0;
}

声明

        因为函数需要：先声明再调用。

        如果要把函数的定义放在main函数之后，要对函数进行声明（因为编译器是自上而下的编译的）。

#include<stdio.h>
#pragma warning(disable:4996);
int find_max(int x, int y);//函数的声明
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d", &a);
	getchar();
	scanf("%d", &b);
	int ret = find_max(a, b);
	printf("最大值：%d\n", ret);
	return 0;
}
int find_max(int x, int y) //函数的定义
{
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}

        注意：函数声明后面要加 ; 号。

应用

        1.写一个函数求X^n的值（x是实数，n为正整数）。

        方法一：定义double型变量ret接收返回值。

        方法二：直接打印返回值。

函数传参

        参数传递：将实际参数的值或地址传递给被调用函数的形式参数，从而在函数中完成对数据处理和返回的过程。

        参数传递的方式

        1.全局变量：

        在所有函数体外的变量，一经定义在程序的任何地方可用。

        比如：下图中的global_a变量

        2.值传递：

        调用函数时，将实参传递给被调用函数，被调用函数将创建同类型的形参并用实参初始化。形参是新开辟的存储空间，在函数中改变形参的值，不会影响到实参的值。        

        举例：编写交换两个数的函数，能用值传递实现吗？

#include<stdio.h>
#pragma warning(disable:4996);
void my_swap(int x, int y);
int main()
{
	int n = 10;
	int m = 20;
	printf("&swap before:n = %p m = %p\n", &n, &m);
	my_swap(n, m);
	printf("swap after: n = %d m = %d\n", n, m);
	printf("&swap after:n = %p m = %p\n", &n, &m);
	return 0;
}
void my_swap(int x, int y)
{
	int t = 0;
	printf("before swap:%d %d\n", x, y);
	printf("&swap before:x = %p y = %p\n", &x, &y);
	t = x;
	x = y;
	y = t;
	printf("after swap: %d %d\n", x, y);
	printf("&swap after:x = %p y = %p\n", &x, &y);
}
//&swap before : n = 0000007383FDFC84 m = 0000007383FDFCA4
//before swap : 10 20
//& swap before : x = 0000007383FDFC60 y = 0000007383FDFC68
//after swap : 20 10
//& swap after : x = 0000007383FDFC60 y = 0000007383FDFC68
//swap after : n = 10 m = 20
//& swap after : n = 0000007383FDFC84 m = 0000007383FDFCA4

        回答：不能，因为交换的是新空间里的值（x = 0000007383FDFC60 y =0000007383FDFC68）。

        应用：

        1.打印 n 以内的所有素数，并统计素数的个数。

        

        3.指针传递：

        按地址传递，实参就是变量的地址，形参就是同类型的指针。

        特征：被调用函数中对形参的操作，将直接改变实参的值。

        应用：

        1.交换两个数字。

#include<stdio.h>
#pragma warning(disable:4996);
void my_swap(int* x, int* y);
int main()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	int* q = &m;
	printf("p = %p,q = %p\n",p,q);
	my_swap(p, q);
	printf("p = %d q = %d", n, m);
	return 0;
}
void my_swap(int* x, int* y)
{
	int temp = 0;
	printf("x = %p,y = %p\n", x, y);
	temp = *y;
	*y = *x;
	*x = temp;
}
//p = 0000000E15B6F504, q = 0000000E15B6F524
//x = 0000000E15B6F504, y = 0000000E15B6F524
//p = 20 q = 10

        2.编写一个函数，统计字符串中小写字母的个数，并把字符串中的小写字母转化成大写字母。    

数组的传参

        建议复习

        “数组名不是指针，但大多数使用到数组名的地方，编译器都会把数组名隐式转换成一个指向数组首元素的指针来处理。”

Day 5~6 ：指针与数组、二维数组

实参、形参归类表（以int类型为例）

分类	实参	形参
一维数组	( arr,n )	( int * q , int n ) or ( int q [ ] , int n )
二维数组—行指针	（arr,n）

一维数组在函数间传参

        ⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

        应用1：编写函数，计算一个一维整形数组的所有元素的和。

#include<stdio.h>	
int fun_sum(int* p, int n);
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int n = sizeof(arr) / sizeof(int);
	int ret = fun_sum(arr, n);
	printf("sum = %d\n", ret);
	return 0;
}
int fun_sum(int* p, int n)      //方法1：形参是指针形式。
//int fun_sum(int p[],int n)    //方法2：形参是数组形式。
{
	int i;
	int sum = 0;
	for (i = 0; i < n; i++)
	{
		sum += p[i];//也可以是：*(p+i)
	}
	return sum;
}
//sum = 15

        应用2：对整型数组进行排序，编写排序函数，并调用、

字符数组在函数间传参

        问题引入：编写函数，删除字符串中的空格。

#include<stdio.h>	
void my_delspace(char* s);
int main()
{
	char ch[] = "ab cd ef g";
	my_delspace(ch);
	printf("%s\n", ch);
	return 0;
}
void my_delspace(char* s)
{
	char* p = s;
	char* q = s;
	while (*p != '\0')
	{
		if (*q != ' ')
		{
			*p = *q;
			p++;
			q++;
		}
		else
		{
			q++;
		}
	}
	*p = '\0';
}

二维数组在函数间传参

一级指针

        问题引入：编写一个函数，打印二维数组。

#include<stdio.h>	
void arr_pri(int* p, int n,int m);
int main()
{
	int arr[3][3] = { {1,2,3},{3,4,5},{5,6,7} };
	int n = sizeof(arr) / sizeof(arr[0]);
	int m = sizeof(arr[0]) / sizeof(int);
	arr_pri(arr[0], n, m);//arr_pri(arr,n,m);error(?)
	return 0;
}
void arr_pri(int* p,int n,int m)
{
	int i;
	for (i = 0; i < n * m; i++)
	{
		printf("%d ", *(p + i));
		printf("%d ", p[i]);
	}
}

行指针

        问题：编写函数，计算一个二维整型数组的奇数的个数。

二级指针

        问题：编写函数，计算一个二维整型数组的奇数的个数。

#include<stdio.h>	
const int N = 2;
const int M = 3;
int get_odd(int** p, int n,int m);
int main()
{
	int arr[N][M] = { {1,2,3},{4,5,6} };
	int* p[N] = { arr[0],arr[1]};
	int r = get_odd(p, 2, 3);
	printf("%d", r);
	return 0;
}
int get_odd(int** p,int n,int m)
{
	int i, j,sum=0;
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			if (*(p[i] + j) % 2 != 0)
			{
				sum++;
			}
		}
	}
	return sum;
}