#3函数#

于 2022-12-01 10:35:09 发布
阅读量116 收藏
点赞数 1
分类专栏： C 文章标签： c# c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szh0331/article/details/128125758
版权

1.函数是什么?

子程序

子程序是一个大型程序中的某部分代码， 由一个或多个语句块组成。

它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

函数分为库函数和自定义函数

2.库函数

C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

使用库函数，必须包含 #include 对应的头文件

MSDN(Microsoft Developer Network)

www.cplusplus.com

http://en.cppreference.com（英文版）

http://zh.cppreference.com（中文版）

可以查询C语言中的库函数

strcpy

把 source 所指向的字符串复制到 destination。

char * strcpy ( char * destination, const char * source );

  • destination -- 指向用于存储复制内容的目标数组。
  • source -- 要复制的字符串。

memset

复制字符 value（一个无符号字符）到参数 ptr 所指向的字符串的前 num个字符。

void * memset ( void * ptr, int value, size_t num );

  • ptr -- 指向要填充的内存块。
  • value -- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
  • num -- 要被设置为该值的字符数。

3.自定义函数

ret_type fun_name(para1, * )

{

        statement;//语句项

}

ret_type 返回类型

fun_name 函数名

para1    函数参数

写一个函数找出两个整数中的最大值

int get_max(int x,int y)//a对应x b对应y 返回类型为int
{
	if(x>y)
	return x;//x大 返回x 
	else
	return y;//反之返回y
}


int main()
{
	int a=10;
	int b=20;
	int max=get_max(a,b);//自定义函数 a b作为两个参数传给函数
	printf("max=%d\n",max);
	return 0;
}

写一个函数可以交换两个整形变量的内容

void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}
void Swap2(int *px, int *py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int num1 = 1;
	int num2 = 2;
	Swap1(num1, num2);
	printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
	Swap2(&num1, &num2);
	printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
	return 0;
}

swap1不会完成交换  传值操作 就是把num1 num2的值传过去

实参传给形参 形参是实参的发一份临时拷贝 对形参的修改是不会影响实参的

swap2会完成交换      传址操作 就是把num1 num2的地址传过去

x与y和num1与num2产生关系 最后会交换num1和num2

4.函数的参数

实参

真实传给函数的参数，叫实参。

实参可以是：常量、变量、表达式、函数等。

无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

形参

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

上面Swap1和Swap2函数的参数x y px py都是形式参数

main函数中的&num1 &num2 num1 num2都是实际参数

实参num1 num2和形参x y不是同一空间 

5.函数的调用

传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。

这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操 作函数外部的变量。

练习

1. 写一个函数可以判断一个数是不是素数。

2. 写一个函数判断一年是不是闰年。

3. 写一个函数，实现一个整形有序数组的二分查找。

4. 写一个函数，每调用一次这个函数，就会将 num 的值增加1。

素数

#include<stdio.h>
int is_prime(int n)//是素数返回1 不是返回0 
{
	int j=0;
	for(j=2;j<n;j++)
	{
		if(n%j==0)
		{
			return -1;//return -1 代表不是素数 
		}
	}
	return 1;//n==j的时候直接来这里 全部试除完 再return 1 
}
int main()
{
	int i=0;
	scanf("%d",&i);	
	if(is_prime(i)==1)//再通过返回条件来打印素数和不是素数 
	printf("素数");
	else
	printf("不是素数"); 
	return 0;
}

闰年

#include<stdio.h>
int is_leap_year(int y)//y读取return 后面数值 再传给主函数里的函数括号里面 用if判断 
{
	if((y%4==0&&y%100!=0)||(y%400==0))//闰年判断条件
	return 1;//是闰年 
	else
	return -1;//代表不是闰年 
}
int main()
{
	int year=0;
	scanf("%d",&year); 
	if(1==is_leap_year(year))
	{
		printf("闰年");
	}
	else
	{
		printf("不是闰年");	
	} 
	return 0;
}

二分查找

#include<stdio.h>
int binary_search(int arr[],int k,int sz)
{
	//算法的实现
	//int sz=sizeof(arr)/sizeof(arr[0]);//数组传参传过去 不能这样求 
	int left=0;
	int right=sz-1;
	while(left<=right)
	{
		int mid=(left+right)/2;//写里面 每回循环完都要重新算一遍 
		if(arr[mid]<k)
		{
			left=mid+1;
		} 
		else if(arr[mid]>k)
		{
			right=mid-1;
		}
		else
		{
			return mid;
		}
    }
    return -1;
}
int main()
{
	//二分查找
	//在一个有序数组中查找具体的某个数
	//如果找到了返回下标 找不到的返回-1 
	int arr[]={1,2,3,4,5,6,7,8,9,10};
	int k=7;
	int sz=sizeof(arr)/sizeof(arr[0]);
	//传递过去的是数组arr首元素的地址 本质上arr是一个指针 
	int ret=binary_search(arr,k,sz);
	if(ret==-1)
	{
		printf("找不到指定的数字\n");
	}
	else
	{
		printf("找得到,下标是：%d\n",ret);
	}
	return 0;
 }

自加

#include<stdio.h>
int plus(int *n)
{
	return ++(*n);
}
int main()
{
	int num=0;
	int ret=plus(&num);
	printf("%d",ret);
	return 0;
}

与交换类似 传址操作

传值操作最后无法改变num的值

6.函数的嵌套调用和链式访问

嵌套调用

#include <stdio.h>
void new_line()
{
	printf("hehe\n");
}
void three_line()
{
    int i = 0;
	for(i=0; i<3; i++)
	{
        new_line();
	}
}
int main()
{
	three_line();
	return 0;
}

打印三次hehe

函数可以嵌套调用，但是不能嵌套定义。

链式访问

把一个函数的返回值作为另外一个函数的参数。

#include <stdio.h>
#include <string.h>//strlen函数计算长度所需头文件  
int main()
{
    char arr[20] = "hello";
    int ret = strlen(strcat(arr,"bit"));//stract库函数 bit添加到数组arr的后面 
    printf("%d\n", ret);//hellobit 结果为8 
    return 0;
}

#include<stdio.h>
int main()
{
	printf("%d",printf("%d",printf("%d",43)));//printf返回值是写入的字符总数 最后打印4321 
	return 0;
}

7.函数的声明和定义

声明

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数 声明决定不了。

2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。

3. 函数的声明一般要放在头文件中的。

定义

函数的定义是指函数的具体实现，交待函数的功能实现。



8.函数递归

什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。

递归做为一种算法在程序设计语言中广泛应用。

一个过程或函数在其定义或说明中有直接或间接调用自身的 一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解， 递归策略 只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于：把大事化小

递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。

每次递归调用之后越来越接近这个限制条件。

练习

1.接受一个整型值（无符号），按照顺序打印它的每一位 例如： 输入：1234，输出 1 2 3 4

2.编写函数不允许创建临时变量，求字符串的长度。

3.求n的阶乘。（不考虑溢出）

4.求第n个斐波那契数。（不考虑溢出）

1打印

#include<stdio.h>
void print(int n)
{
	if(n>9)
	{
		print(n/10);//调用完后 执行完会回来 一直打印 1 2 3 4 
	}
	printf("%d ",n%10);
}
int main()
{
	unsigned int num=0;
	scanf("%d",&num);
	print(num);
	//1234
	//123 4
	//12 3 4
	//1 2 3 4拆开 
	return 0;
}

2字符串长度
不递归

#include<stdio.h>
#include<string.h>

int my_strlen(char*str)
{
	int count=0;
	while(*str!='\0')
	{
		count++; 
		str++;//字符串 往下跳 count计数 
	}
	return count;
}
int main()
{
	char arr[]="bit";
	int len=my_strlen(arr);//arr是数组 数组传参 传过去的是第一个元素的地址 
	printf("len=%d\n",len);
	return 0;
}

递归

#include<stdio.h>
#include<string.h>

int my_strlen(char*str)
{
	if(*str!='\0')
	{
		return 1+my_strlen(str+1);
	}
	else
	{
		return 0;
	}
}
//my_strlen("bit")
//1+my_strlen("it")
//继续 
int main()
{
	char arr[]="bit";
	int len=my_strlen(arr);//arr是数组 数组传参 传过去的是第一个元素的地址 
	printf("len=%d\n",len);
	return 0;
}

3n的阶乘

#include<stdio.h>
int Fac2(int n)
{
	if(n<=1)//n=1时 1的阶乘为1 直接返回1 
	return 1;
	else
	return n*Fac2(n-1);//Fac(n-1)会再走一遍函数 这时候n-1为判断条件   
}
int main()
{
	int n=0;
	int ret=0;
	scanf("%d",&n);
	ret=Fac2(n);
	printf("%d\n",ret);
	return 0;
}

4斐波那契数列/青蛙跳台阶问题

不用递归

#include<stdio.h>
int Fib(int n)
{
	long long int a=1;//n<=2时 返回1 
	long long int b=1;
	long long int c=1;
	while(n>2)//循环实现 效率高于递归
	{
		c=a+b;
		a=b; 
		b=c;
		n--;//算的次数 
	}
	return c;
}
int main()
{
	long long int n=0;//定义n 求第n个 
	long long int ret=0;//ret 最后结果 
	scanf("%d",&n);//输入n 
	ret=Fib(n);//ret=函数()最后结果 
	printf("ret=%d\n",ret);
	return 0;
}

递归

#include<stdio.h>
int Fib(int n)
{
	if(n<=2)
	return 1;
	else
	return Fib(n-1)+Fib(n-2);//利用函数返回 求过大数字会运行很慢 
}
int main()
{
	int n=0;
	int ret=0;
	scanf("%d",&n);
	ret=Fib(n);
	printf("ret=%d\n",ret);
	return 0;
}

#3函数#完

努力的小恒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力的小恒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值