函数 2024.01.31

实参和形参

实参：可以是常量、变量、表达式

形参：可以是常量；在定义函数中的形参，在未出现调用时，他们不占用内存中的存储单元，只有在发生函数调用时，形参才会被分配内存单元。在调用结束后，形参所占的内存单元也被释放。

在被定义的函数中，必须指定形参的类型；

实参与形参的类型应相同或赋值兼容；

实参向形参的数据传递是“值传递”，单向传递，只有实参传给形参；

函数的声明和定义

被调函数在主调函数之前，如果被调函数在主调函数之后，在主函数调用之前

先进行声明。

函数的声明；函数的定义

函数的定义不可以被嵌套，函数的调用可以嵌套

函数传参时，自右向左传递，先传 j,再传递 i

传参

传参值传递：

实参传递给形参，在被调函数修改形参，不会影响到实参的值，无法修改主调

形参是实参的复制品，二者有不同的内存空间

指针传参：

可以通过实参的地址修改实参的值

三级流水线结构

RAM负责存，PC负责取 ，cpu负责执行

 五个区：  都在RAM里面

栈：先进后出，后进先出

103当调f1时，先存main的地址,存f1的入口地址，存f2的地址；

调完了之后，去f2地址到f2，再到f1，到main。

栈区：保存了函数定义时，保存的形参空间

函数调用后返回的地址

函数调用的局部变量

在linux系统下，栈区最大8兆

windows系统下，栈区最大1兆；

函数的递归调用（非重点zhu）

在调用

求1+2+3+.....+n的和；

计算n的阶乘

#include<stdio.h>
int fn(int n)
{
	if(1 == n)
	{
		return 1;
	}
	else
	{
		return fn(n - 1) * n;
	}

}
int main(void)
{
	printf("%d\n",fn(3));
	return 0;
}

数据作为函数参数（重点）

隐藏的含义是指针传参

传入的参数：数组名a，数组的长度

1.求数组内各个元素之和

int sumOfArray(int a[],int len)
{
	int i;
	int sum = 0;
	for(i = 0;i < len;++i)
	{
		sum = sum + a[i];
	}
	return sum;
}
int main(void)
{
	int a[] = {1,2,3,4,5};
	printf("%d\n", sumOfArray(a,sizeof(a) / sizeof(a[0])));
	return 0;
}

2.一维数组的逆序

void reverse(int a[],int len)
{
	int i;
	for(i = 0;i < len / 2;++i)
	{
		int t = a[i];
	    a[i] = a[len - i - 1];
		a[len - i - 1] = t;
	}

}
int main(void)
{
	int a[] = {1,2,3,4,5};
	int len = sizeof(a) / sizeof(a[0]);
	reverse(a,len);
	return 0;
}

3.一维数组的选择排序和二分法查找

void choicSort(int a[],int len)
{
	int i,j;
	for(i = 0;i < len - 1;++i)
	{
		for(j = i + 1;j < len;++j)
		{
			if(a[i] > a[j])
			{
				int t = a[i];
				a[i] = a[j];
				a[j] = t;
			}
		}
	}
	for(i = 0;i < len;++i)
	{
		printf("%d\n",a[i]);
		
	}

}

int binaryFind(int a[],int len,int n)
{
	int begin = 0l;
	int end = len - 1;
	int mid;
	while(begin <= end)
	{
		mid = (begin + end) / 2;
		if(n > a[mid])
		{
			begin = mid + 1;
		}
		else if(n < a[mid])
		{
			end = mid - 1;
		}
		else 
		{
			break;
		}
	}
	if(begin <= end)
	{
		return mid;

	}
	else
	{
		return -1;
	}
}
int main(void)
{
	int a[] = {1,2,14,5};
	int len = sizeof(a) / sizeof(a[0]);
	choicSort(a,len);
	reverse(a,len);
    int ret = binaryFind(a,5,2);
	if(ret < 0)
	{
		puts("not");
	}
	else
	{
		puts("yes");
	}
	return 0;	
}

4.二维数组逆序及打印

void reverse2(int a[][4],int rows)
{
	int i,j;
	int cols = sizeof(a[0]) / sizeof(a[0][0]);
	for(i = 0;i < rows;++i)
	{
		for(j = 0;j < cols / 2;++j)
		{
			int t = a[i][j];
		
			a[i][j] = a[i][cols - j - 1];
			a[i][cols - j - 1] = t;
		}
	}
	
}
void printfArray2(int a[][4],int rows)
{
	int cols = sizeof(a[0]) / sizeof(a[0][0]);
	int i,j;
	for(i = 0;i < rows;++i)
	{
		for(j = 0;j < cols;++j)
		{
			printf("%2d",a[i][j]);
		}
		puts("");
	}
}
int main(void)
{
	int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
	int rows = sizeof(a) / sizeof(a[0]);
reverse2(a,rows);
	printfArray2(a,rows);
}

5.二维字符型数组

void mystrcpy(char s1[100],char s2[100])            //将s2拷贝到s1中
{
	int i = 0;
	while(s2[i] != 0)
	{
		s1[i] = s2[i];
		++i;
	}
	s1[i] = 0;
}
int mystrcmp(char s1[],char s2[])                  //比较s1和s2
{
	int i = 0;
	while(s1[i] == s2[i] && s1[i] && s2[i])
	{
		++i;
	}
	return s1[i] - s2[i];
}
void reverseStrings(char s[][100],int rows)           //逆序
{
	int i;
	for(i = 0;i < rows / 2;++i)
	{
		char t[100];
		mystrcpy(t,s[i]);
		mystrcpy(s[i],s[rows - i -1]);
		mystrcpy(s[rows - i - 1],t);
	}
}
void sortString(char s[][100],int rows)                //比较并排序
{
	int i,j;
	for(i = 0;i < rows - 1;++i)
	{
		for(j = i + 1;j < rows; ++j)
		{
			if(mystrcmp(s[i], s[j]) > 0)
				{
					char t[100];
					mystrcpy(t, s[i]);
					mystrcpy(s[i], s[j]);
					mystrcpy(s[j], t);
				}
		}
	}
}
int binaryFindString(char s[][100], int rows, char n[100])           //二分查找
{
	int i;

	int begin = 0;
	int end = rows - 1;
	while(begin <= end)
	{
		int mid = (begin + end) / 2;
		if(mystrcmp(s[mid] ,n) > 0)
		{
			end = mid - 1;
		}
		else if(mystrcmp(s[mid], n) < 0)
		{
			begin = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

void PPuts(char s[][100],int rows)                    //二维字符型数组输出函数
{
	int j;
	for(j = 0;j < rows;++j)
	{
		puts(s[j]);
	}
}
int main(void)                                         //主函数
{
	int i;
	char s[][100] = {"Hello","World","Chian","Americ"};
	int rows = sizeof(s) / sizeof(s[0]);
	int cols = sizeof(s[0]) / sizeof(s[0][0]);
//	reverseStrings(s,rows);
	sortString(s,rows);
	int ret = binaryFindString(s,rows,"Hello");
	if(ret < 0)
	{
		puts("no");
	}
	else
	{
		puts("yes");
		printf("%d\n",ret);
	}
	
//	PPuts(s,rows);
	
	return 0;
}