Day17 指针变量做函数形参 指针函数 函数指针

1. 指针变量做函数形参

1.1指针变量做一维数组形参

首先先了解如何定义一个一维数组指针

int arr[5] = {1, 2, 3, 4, 5};//定义一个一维数组
int *parr = arr;//指针指向数组的首地址

方式是在定义函数的时候，入参定义一个指针和数组长度

int function(int *p, int length);

当我们调用这个函数的时候，在入参时第一个参数传递一个地址（数组名即数组的首地址），即可对数组操作

现在可以用函数求一个数组的平均值

#include<stdio.h>

void ave_arr(int *p, int length);

int main()
{
    int arr[5] = {1, 2, 3, 4, 5};

    ave_arr(arr, 5);//数组名即首地址
    return 0;
}

void ave_arr(int *p, int length)
{
    float sum = 0;
    for(int i = 0; i < length; i++)
    {
        sum += p[i];
    }
    printf("数组的平均数是：%f\n", sum / length);
}

函数调用的时候将数组首地址传到函数，用地址对数组进行想要的求和操作，最后输出平均值

1.2 指针变量做二维数组的形参

首先先了解指针指向二维数组的定义：

int arr[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};//定义一个二维数组
int (*parr)[5];//定义一个二维数组指针
parr = arr;//将二维数组指针指向二维数组的首地址

 定义函数时，也可以用二维数组指针定义形参

数据类型       函数名    二维数组指针    行数        列数
int         function(int (*parr)[5], int row, int column)

注意：二维数组后面的[]里是列数，不能省略

那现在做一个练习，利用函数的数组指针，将二维数组赋值、输出、求平均值、求每行的总数、求每列的总数

#include<stdio.h>

void print_arr(int (*parr)[5], int row, int column);//输出函数
void scanf_arr(int (*parr)[5], int row, int column);//赋值函数
void ave_arr(int (*parr)[5], int row, int column);//求平均函数
void sum_row(int (*parr)[5], int row, int column);//每行总和函数
void sum_column(int (*parr)[5], int row, int column);//每列综合函数

int main()
{
	int arr[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
	int (*parr)[5] = arr;
	print_arr(parr, 3, 5);
//	scanf_arr(parr, 3, 5);
//	print_arr(parr, 3, 5);
//	ave_arr(parr, 3, 5);
//	sum_row(parr, 3, 5);
	sum_column(parr, 3, 5);
	
	return 0;
}

void print_arr(int (*parr)[5], int row, int column)
{
	for(int i = 0; i < row; i++)
	{
		for(int j = 0; j < column; j++)
		{
			printf("%d\t", parr[i][j]);
		}
		printf("\n"); 
	}
}

void scanf_arr(int (*parr)[5], int row, int column)
{
	for(int i = 0; i < row; i++)
	{
		for(int j = 0; j < column; j++)
		{
			scanf("%d", &parr[i][j]);
		}
	}
}

void ave_arr(int (*parr)[5], int row, int column)
{
	int sum = 0;
	for(int i = 0; i < row; i++)
	{
		for(int j = 0; j < column; j++)
		{
			sum += parr[i][j];
		}
	}
	printf("数组的平均值是:%d\n", sum / (row * column));
}

void sum_row(int (*parr)[5], int row, int column)
{
	int sum = 0;
	for(int i = 0; i < row; i++)
	{
		
		for(int j = 0; j < column; j++)
		{
			sum += parr[i][j];	
		}
		printf("第%d行的总和为%d\n", i + 1, sum);
		sum = 0;	
	}	
}

void sum_column(int (*parr)[5], int row, int column)
{
	int sum = 0;
	for(int i = 0; i < column; i++)
	{
		
		for(int j = 0; j < row; j++)
		{
			sum += parr[j][i];	
		}
	printf("第%d列的总和为%d\n", i + 1, sum);
	sum = 0;	
	}	
		
} 

2. 指针函数

指针函数的本质是一个函数，只是他的返回值是一个指针

定义：

类型    *函数名    (形参列表)
int    *function()
{
    ...
    return p;//p是一个指针
}

由于局部变量的地址不能返回，那么我们就设置一个全局变量来定义一个指针函数将它的地址返回

#include<stdio.h> 
//1.局部变量的地址不能返回
//2.指针函数：他的返回值是一个指针 

char str[100] = "hello world";//全局变量

char *function(); //指针函数的声明

int main()
{
	char *p = function();//指针函数的调用，用一个指针来接返回值
	printf("%s", p);
	
	return 0;
}

char *function()
{
//	char str[100] = "hello world";//局部变量的地址不能返回，如果在这里定义的变量，是没有返回值的
	return str;//返回一个指针
}

3. 函数指针

本质是一个指针，它指向一个函数

注：函数的名字就是函数的首地址，即函数的入口地址，我们可以定义一个指针变量来存放函数的地址

定义：

int max(int a, int b)
{
    return a > b ? a : b;
}

int min(int a, int b)
{
    return a < b ? a : b;
}

int main()
{
    int a = 10;
    int b = 20;
    int (*p)(int, int)//定义一个函数指针，后面两个参数必须和调用函数严格匹配
    p = max;//  p指向max函数
    p(a, b);    //调用max函数
    p = min;//  p指向min函数
    p(a, b);//    调用min函数
    
}

现在可以做加减乘除取余的函数，然后用函数指针去调用函数

#include<stdio.h>

int add(int a, int b);//加函数
int sub(int a, int b);//减函数
int div(int a, int b);//除函数
int mul(int a, int b);//乘函数
int remaind(int a, int b);//取余函数

int main()
{
	int a = 10;
	int b = 20;
	int (*p)(int , int );//定义一个函数指针 
	p = div;//让函数指针指向除函数的首地址
	
	printf("%d\n", p(a, b));//调用此函数
	
	p = mul;
	printf("%d\n", p(a, b));//...
	
	p = sub;
	printf("%d\n", p(a, b));//...
	
	p = remaind;
	printf("%d\n", p(a, b));//...
	
	p = add;
	printf("%d\n", p(a, b));//...

	 
	return 0;
}

int add(int a, int b)
{
	return a + b;
}

int sub(int a, int b)
{
	return a - b;
}

int mul(int a, int b)
{
	return a * b;
}

int div(int a, int b)
{
	return a / b;
}

int remaind(int a, int b)
{
	return a % b;
}