C语言-函数（详尽版）_c语言函数

目录

函数【C语言的第二个重点】：

 什么叫做函数

如何定义函数

函数的分类

函数注意的问题

形参和实参

常用的系统函数

变量的作用域和存储方式 

---

函数【C语言的第二个重点】：

     为什么需要函数：【定义之后就把他当工具来使用】

           操作一样，针对的数据不一样，我们就需要减少代码量，来使用函数来简化这些代码量，

           函数使用完毕之后，空间就会释放，不然的话每次调用占一块空间 

           那调用100次，内存不就爆炸了（满了）！

           程序一定从main()函数开始，也一定从main()结束

           避免了重复性操作，有利于模块化

代码举例：

# include <stdio.h>
/*
函数第一个例子
*/
 
 
//定义一个无返回值，函数名字为max，两个形式参数
void max(int i, int j) //后面不要加分号！！！
{
	if (i > j)
		printf("%d\n", i);
	else
		printf("%d\n", j);
}
int main(void)
{
	int a,b,c,d,e,f;
	a = 1, b = 2, c = 3, d = 9;
    e = -5, f = 100;
 
 
	max(a,b); //调用函数时，直接加函数名和要操作的的变量
	max(c,d);
	max(e,f);
 
 
/*	
	if (a > b) //第一个if -else
		printf("%d\n", a);
	else
		printf("%d\n",b);
	
	if (c > d) //和第一个一样if-else
		printf("%d\n", c);
	else
		printf("%d\n",d);
	
	if (e > f) //又和第一个重复了，此时我们就要用函数l简化代码
		printf("%d\n", e);
	else
		printf("%d\n",f);
	
*/	
	
	return 0;
}

          

          

    什么叫做函数

           逻辑上：能够完成特定功能代码块

           物理上：

              能够接收数据int f（int i），也可以不接受数据

                        int f(void)

              能够对接收的数据进行处理 调用时函数名加处理的数据

                        如f（10）能够将处理得到数据返回值int f（int i）

                        要与return配套使用，也可以没有返回值void（int i）

                        处理完之后没有return的函数                                                  

             

           总结：函数是一个工具，它是为了解决大量类似问题而设计的

                     函数可以当成一个黑夹子（只管输入数据，他给我一个

                        结果就行了）

             

             

                        

如何定义函数

           函数的返回值类型 函数的名字（函数的形参列表）

           {

              函数的执行体；

                  }

           例如：int max（int i， int j）

               {

                  if（i>j）

                     printf("%d",i);

                  else

                     printf("%d",j);

              }

          

           1.函数的定义本质是详细描述函数之所以能够实现某个特定功能

             的具体方法。   

代码如下

          

           2.return 表达式（重点）：含义：

              1> 终止被调函数，向主调函数返回表达式的值                        

              2> 如果表达式为空，则终止函数，不向被调函数返回

                 任何值

                 例如：

                     void f（）

                         {

                            return；//单纯的终止函数

                         }

                     int f（）

                         {

                            return 10；//终止函数，并向

                                   被调函数返回

                                                            了一个值             

                         }

   

        3.函数返回值的类型也称函数的类型，因为如果函数名前的返回和函数执行体中的return表达式；中表达式的类型不同的话则最终函数返回值类型以函数名前的返回值类型为准

           代码如下：到底什么什么函数类型

# include <stdio.h>
/*
	到底什么是函数返回值类型
	
*/
 
int f()
{ //函数的返回值类型与return 表达式不同，以函数返回值类型为准
	//该函数返回值是10，而不是10.5
	return 10.5;
}
 
 
 
 
int main(void)
{
	
	float x = 6;
	
	x = f();//f()返回的是一个整型变量10，放到x中
	printf("%f\n", x);
 
 
	return 0;
}

       4.return和break的区别：return是终止函数的，break是终止函数

        代码举例：

# include <stdio.h>
/*
	return和break的区别
*/
 
void f(void)
{
	int i;
 
	for (i=0; i<5; i++)
	{
		printf("大家辛苦了！\n");
		break;
	}
 
	printf("同志们好！\n");
 
 
}
 
void g(void)
{
	int i;
 
	for (i=0; i<5; i++)
	{
		printf("大家辛苦了！\n");
		return ; //return不是终止for循环的，而是终止g()函数的
	}
 
	printf("同志们好！\n");
 
 
}
 
//主调函数
int main(void)
{
	printf("下面为break执行的结果\n");
 
	f();
 
	printf("------------\n");
	printf("下面为return执行的结果\n");
 
	g();
 
 
 
	return 0;
}
/*
执行结果
------------------
下面为break执行的结果
大家辛苦了！
同志们好！
------------
下面为return执行的结果
大家辛苦了！
------------------
总结：return是终止函数的，break是终止循环的
*/

      5.函数在输出时，可以在被调函数里直接将函数输出也可以通

             return将函数处理过的结果返回到函数中在通过主调函数进行

             输出，简单言之就是处理过的结果可以直接在被调函数里直输

         也可以通过main函数（主函数）里输出，但是要利用return语  句将结果返回到函数中去中去（ 实际上函数名也是一个地址），将返回的值返回到函数中之后，通过主函数使用处理过的结果 值    

例子如下代码：函数举例_1

# include <stdio.h>
/*
函数第一个例子
*/
 
 
//定义一个无返回值函数名字为max含有形式参数的被调函数
void max(int i, int j) //后面不要加分号！！！
{
	if (i > j)
		printf("%d\n", i);
	else
		printf("%d\n", j);
}
 
//被调函数
int  max2(int i, int j)
{
	if (i > j)
		return i; //把值返回给被调函数max2（实参）
	else
		return j;
}
 
//主调函数
int main(void)
{
	int a,b,z;
	a = 1, b = 2; 
    
	//结果通主调函数输出
	z = max2(a,b);//通过return语句将传入的数据处理过的结果返回到函数名中（相当于地址）
 
	printf("在主调函数输出为%d\n", z);
 
 
 
	printf("结果在被调函数输出为");
  //结果在被调函数就被输出	
	max(a,b); //调用函数时，直接加函数名和要操作的的变量
 
 
 
 
	
	return 0;
}
/*
输出结果
----------------
在主调函数输出为2
结果在被调函数输出为2
---------------------
总结：
       函数在输出时，可以在被调函数里里直接将函数输出，也可以通
	   return将函数处理过的结果返回到函数中在通过主调函数进行
	   输出，简单言之就是处理过的结果可以直接在被调函数里直接输
      也可以通过main函数（主函数）里输出，但是要利用return语  
	  句将结果返回到函数中去中去（实际上函数名也是一个地址）
       将返回的值返回到函数中之后，通过主函数使用处理过的结果值     
 
*/

          

代码举例_2：判断素数

# include <stdio.h>
# define true 1
# define false 0
/*
编一个输出素数函数
素数：只能被1和自己整除,且1不是素数
解题思路：假如我们判断9是不是素数
除去1和本身，从2-8只要
有一个被9整除，则该数就不是素数
很明显在2-8,3能够被9整除即9不是素数
*/
 
//定义一个素数判断的函数
int IsPrime(int val)
{
	int i;
	
	for(i=2; i<val; i++)
	{//从2到val-1中找到能否被val整除的数
		if(val%i == 0)
			break;
	}
	
	// 输出是否为素数
	if (val == i)
		return true;
	else
		return false;
	
	
	
}
 
 
//主调函数
int main(void)
{
	int k;
	char ch;
	int val; //定义要输入的数
	
	do
	{
 
	printf("请输入一个数: ");
	scanf("%d", &val);//接收键盘输入的值
 
	k = IsPrime(val); //将传入的值放入k中
	
	printf("%d\n", k);
 
	printf("是否继续(Y/N):");
	scanf(" %c", &ch);
 
	} while(ch=='y' || 'Y'==ch);
 
 
	return 0;
}

   

函数的分类

           有参函数 和 无参函数

           有返回值 和 无返回值

           库函数  和 用户自定义函数

           值传递 和 地址传递(指针)

           普通函数 和 主函数（main函数）

              一个函数必须有且仅有一个主函数

              普通函数不能调用主函数（如递归）

              普通函数可以相互调用

              主函数是程序的入口，也是程序的出口

代码举例：函数举例

# include <stdio.h>
/*
2023年6月15日11:26:24
函数复习例子
*/
void f() //无参无返回值
{
	printf("f()是无参无返回值\n");
}
 
void f(int i) //有参无返回值
{
	printf("f(int i)是有参无返回值\n");
}
 
int f1() //无参有返回值
{	
	return 1;	
}
 
int f1(int val)//有参有返回值
{
	int sum = 0;
	int i;
 
	for (i=1; i<val; i++)
	{
		sum = sum + i;
	}
	return sum;
}
 
 
 
 
int main(void)
{
	int i;
	
	 f();
	 
	 f(2);
 
	printf("f1()是无参有返回值通过return返回一个int型变量值为：%d\n",f1());
	
	printf("f1(int i)是有参有返回值通过return返回一个sum值为：%d\n", f1(10));
 
	return 0;
}
 
/*
执行结果
-----------------
f()是无参无返回值
f(int i)是有参无返回值
f1()是无参有返回值通过return返回一个int型变量值为：1
f1(int i)是有参有返回值通过return返回一个sum值为：45
-----------------
*/ 

判断素数代码优化：

代码1：

# include <stdio.h>
/*
	
	如何合理设计一个函数
	判断一个函数是否是素数
	一个函数实现它
*/
bool f(int val)//判断是否为素数
{
	int i;
 
	for (i=2; i<val; i++) //从2~val-1循环
	{
		if(val%i == 0) //判断在2~val-1是否存在能被val整除的数
			break; //找到就退出循环
	}
 
	if (i == val) //如果val和i相等就是素数
		return true;//是就返回真
	else
		return false;//否则就返回假
 
}
 
 
int main(void)
{
	int val;
	int k;
 
	printf("请输入一个数:");
	scanf("%d", &val);
 
	k = f(val);
 
	if(k == 1)
		printf("是素数！\n");
	else
		printf("不是素数！\n");
 
 
	return 0;
}

代码2：

# include <stdio.h>
/*
	2023年6月15日17:32:46
	求1到某个数字之间（包括该数字）所有的素数,并将其输出
	用单独函数实现，代码的可重复性提高
	只用main函数实现，有局限性
	   1.代码重复性不高
	   2.代码也不容易理解
*/
 
 
 
 
 
int main()
{
	int val;
	int i;
	int j;
	
	scanf("%d",&val);
 
	for (i=2; i<=val; i++) 
	{ //判断i是否为为素数，是就输出，不是不输出
		for (j=2; j<i; j++)
		{
			if (i%j == 0)
				break;
		}
 
		if (j == i)
			printf("%d\n",i);
	}
 
 
	return 0;
}

代码3：进行模块化

# include <stdio.h>
/*
	2023年6月15日17:32:46
	求1到某个数字之间（包括该数字）所有的素数,并将其输出
	用单独函数实现，代码的可重复性提高
	用一个函数实现比在main单独实现可读性更好
	用函数实现
*/
 
bool IsPrime(int m)
{
	int j;
 
	for (j=2; j<m; j++)
	{
		if (m%j == 0)
			break;
	}
	
	if (j == m)
		return true;
}
 
 
void IsPrime2(int val)
{
	int i;
	int k;
 
	for (i=2; i<=val; i++) 
	{ //判断i是否为为素数，是就输出，不是不输出
		
		k = IsPrime(i);
		
		if (1 == k)
			printf("%d\n", i);
	}
}
 
 
 
int main()
{
	
	int val;
 
	scanf("%d",&val);
	
	IsPrime2(val);
 
	
 
 
	return 0;
}

代码4：再次进行模块化

# include <stdio.h>
/*
	2023年6月15日17:32:46
	求1到某个数字之间（包括该数字）所有的素数,并将其输出
	用单独函数实现，代码的可重复性提高
	用一个函数实现比在main单独实现可读性更好
	函数实现：主要里函数的使用
*/
bool IsPrime(int m);//函数声明
void IsPrime2(int val);
 
void TraverseVal() //把1-n之间所有的素数输出,输出几遍
{
	int i;
	int val;
	int n;
	int count = 0;
 
	scanf("%d %d",&val, &n);
	for (i=0; i<n; i++)
	{
		count++;
		printf("第%d遍历开始\n",count);
		printf("----------------\n");
		IsPrime2(val);
		
	}
 
 
}
 
bool IsPrime(int m)//判断m是否是素数，是返回true，不是返回false
{
	int j;
 
	for (j=2; j<m; j++)
	{
		if (m%j == 0)
			break;
	}
	
	if (j == m)
		return true;
}
 
 
void IsPrime2(int val)
{
	int i;
	int k;
 
	for (i=2; i<=val; i++) 
	{ //判断i是否为为素数，是就输出，不是不输出
		
		k = IsPrime(i);
		
		if (1 == k)
			printf("%d\n", i);
	}
}
 
 
//主函数
int main()
{
 
	TraverseVal();
 
 
	return 0;
}

函数注意的问题

 函数定义的顺序  

1.函数声明格式：返回值类型 函数名（参数）；例如voidf(void);一定要在开头，函数神声明是一条语句，一定要有分号‘’

2.函数声明1：函数声明,程序都是从上往下执行的，如果被调函数在主函数下面定义一定                要声明，声明时分号能不能丢掉

代码如下：函数声明1

# include <stdio.h>
/*
	函数声明,程序都是从上往下执行的，如果被调函数在主函数下面定义一定要声明
*/
 
void f(void); //函数声明，分号不能丢掉
 
int main()
{
	f();
	return 0;
}
 
void f(void)
{
	printf("哈哈！\n");
}

             

3.函数声明2：函数声明一定要定义在主调函数前或另一个被调函数前面不然会报错，解决方法：前置声明被调函数1调用被调函数2被调用的一定要在前，在后的话 一定要声明，在函数开头声明，声明一定 要有分号

 

代码如下：函数声明_2

# include <stdio.h>
/*
2023年6月15日16:13:11
	函数声明2，一个被调函数调用另一个被调函数，
	          被调函数在后，主被调函数在前，一定要声明
*/
void f(void);//函数声明
 
void g(void)//被调函数1
{
	f(); //被调函数1调用被调函数2被调用的一定要在前，在后的话一定要声明	
}
 
void f()//被调函数2
{
 
	printf("哈哈！\n");
}
 
int main()
{
	g();
 
	return 0;
}

 

4.对库函数的声明通过# include <库函数所在文件的名字.h>来实现的（如printf库函数）

5.void的含义：

# include <stdio.h>
/*
     void 含义
     f()是被调函数，调用的函数是主调函数 如main()函数调用f()
*/
 
int f(void) //括号中的void表示该函数不能接收数据，int表示该函数返回值是int类型的数据
{            //该函数有返回值 返回一个int类型的值
	return 10; //向主调函数返回10
}
 
 
void g(void) //定义一个无返回值的函数g()
{
  //return 0; //函数是无返回值的不能加return，与void相矛盾
}
 
int main()
{
	int j = 88;
	int i = 10;
	
	j = f(); //将f()的返回值放到j变量中
	printf("%d\n", j);
	
	i = g();
	printf("%d\n", i);
	return 0;
}

          

形参和实参

           形参定义格式：

                 类型返回值 函数名（形式参数1，形式参数2 ...）

                 每个形式参数以逗号隔开

           形参：形式参数，例如函数定义时：int f（int i），这个i

                      就是一个形式参数，没有实际意义，当主调函数的实参

                     传入形参，这时候形参才有实际意义，

          实参：顾名思义实际参数，例如f(4);括号里面有个具体值，一   

              定是个具体数值，如果是形参也是被赋了具体值的形参
              总之，一定是个值，有实际意义的数值。

           两者有什么关系？

              形参和实参必须一一对应，形参有几个，实参 就必须有几个例如 int f(int i, int j)的

              形参有两个则实参必须传入两个如f（2,3）

       如何在软件开发过程中合理的设计函数来解决实际问题（重点）？

           多模仿牛人，一个函数功能尽量独立 

                 

常用的系统函数

           double sqrt(double x); 求x的平方根

           int abs(int x); 求x绝对值

           double fabs(double x);求x的绝对值

           引用以上需加上预编译头文件#incldue<math.h>

           printf（）scanf() 引用以上需加上预编译头文件

           #include<stdio.h>,stdio.h是标准输入输出文件

   

变量的作用域和存储方式 

           按作用域分：

                    全局变量：在所有函数外定义的就属于全局变量

                      

                   局部变量：在函数内部定义的变量或者函数的形参

代码举例如下：

# include <stdio.h>
/*
	全局变量和局部变量
*/
 
int k = 1000;//全局变量  在最顶端
 
void f(int i)
{
	//int i;与形参定义重复，形参内的定义的也相当于局部变量
    int k = 20;//局部变量
 
}
 
void g()
{
	printf("%d\n", k);//函数内部使用的是全局变量
}
 
int main()
{
	int k = 30;//局部变量
 
	printf("%d\n", k);//输出局部变量30
	
	g();
 
	return 0;
		
}

                    

           按变量的存储方式分：

                  静态变量：static关键字：分配的一块静态

                                    存储空间 ，用完不释放

                  自动变量：auto关键字：

                                   运行在堆栈中的动态分配内存

                                   用完就释放

                  寄存器变量：register关键字：也是一中存储

                                      数据的变量，只不过是将变量和寄存

                                      相关联，执行效率特别高

             

    专题：

       递归：数据结构内容（郝斌数据结构）

递归的概念，递归指的是一个函数自己调用自己，首先我们知道主函数main只能有一个也不可能被其他函数调用，所以我们肯定要写一个子函数，然后再子函数里用递归。然后我们去找递归的结束标志，如果没有结束标志，那么这个递归程序会一直调用自己，导致你的程序崩溃，所以去找递归的结束标志很重要。很明显，当n的值等于1的时候，我们就不用再调用自己了，然后返回到上一层，乘上这一层的n，然后再一层一层返回，每返回一层，n的值就比返回的n大1，直到返回到第一层的时候，就是我们的第一个乘数。这样我们就模拟出了阶乘的算法，然后再返回给主函数打印。 

    递归举例：求阶乘

题目: 利用递归方法实现一个函数,该函数能够实现n的阶乘,即 n! = n*(n-1)*…*3*2*1;
 
#include <stdio.h>
 
int factorial(int n)
{
	if(n == 1)  //结束递归判断条件
	{
		return;
	}
	return n*factorial(n - 1); //递归调用自己
}
 
int main()
{
	int n;
	
	printf("please input a number:\n");
	scanf("%d",&n);
	
	printf("result = %d\n",factorial(n));
	
	return 0;
}