《带参带返回值函数》PPT课件

合集下载

函数完整版PPT课件

函数完整版PPT课件
16
三角函数图像变换规律
振幅变换
通过改变函数前的系数,实现对函数图 像的纵向拉伸或压缩。
周期变换
通过改变函数内的系数,实现对函数图 像的横向拉伸或压缩。
2024/1/28
相位变换
通过改变函数内的常数项,实现对函数 图像的左右平移。
上下平移
通过在函数后加减常数,实现对函数图 像的上下平移。
17
三角函数周期性、奇偶性和单调性
了直线在 $y$ 轴上的位置。
03
性质
当 $k > 0$ 时,函数单调递增 ;当 $k < 0$ 时,函数单调递
减。
8
二次函数表达式与图像
2024/1/28
二次函数表达式
$y = ax^2 + bx + c$($a neq 0$)
图像特点
一条抛物线,开口方向由 $a$ 决定($a > 0$ 时向上开口 ,$a < 0$ 时向下开口),对称轴为 $x = -frac{b}{2a}$ ,顶点坐标为 $left(-frac{b}{2a}, c frac{b^2}{4a}right)$。
对数函数性质
单调性、定义域、值域等 。
13
指数对数方程求解
指数方程求解
通过换元法、配方法等方法将指数方 程转化为代数方程求解。
指数对数混合方程求解
综合运用指数和对数的性质及运算法 则进行求解。
对数方程求解
通过换底公式、消去对数等方法将对 数方程转化为代数方程求解。
2024/1/28
14
04
三角函数及其性质
函数完整版PPT课件
2024/1/28
1
目录
2024/1/28
• 函数基本概念与性质 • 一次函数与二次函数 • 指数函数与对数函数 • 三角函数及其性质 • 反三角函数及其性质 • 复合函数与分段函数 • 参数方程与极坐标方程

函数的返回值、函数的调用、函数的参数

函数的返回值、函数的调用、函数的参数

函数的返回值、函数的调⽤、函数的参数1、函数的返回值'''1、什么是返回值返回值是⼀个函数的处理结果,2、为什么要有返回值如果我们需要在程序中拿到函数的处理结果做进⼀步的处理,则需要函数必须有返回值3、函数的返回值的应⽤函数的返回值⽤return去定义格式为:return 值 --------(值可以是是以数据类型)注意:1、return是⼀个函数结束的标志,函数内可以有多个return,但只要执⾏⼀次,整个函数就会结束运⾏------即函数下⾯有再多代码也不会被执⾏2、return 的返回值⽆类型限制,即可以是任意数据类型------------如整型、字符串、列表、元组、等3、return 的返回值⽆个数限制,即可以⽤逗号分隔开多个任意类型的值0个:返回None,ps:不写return默认会在函数的最后⼀⾏添加return None------即没有return函数代码运⾏完毕也会结束运⾏1个:返回的值就是该值本⾝多个:返回值是元组--------------------调⽤函数会将多个任意类型的值放到元组中返回'''# def max2(x,y): #x=3000,y=2000# if x > y:# return x #return 3000# else:# return y #reuturn 2000## res=max2(3000,2000) #函数正常调⽤,赋值给⼀个变量,可以拿到⼀个返回值## # annual_salary=res * 12 #函数当做⼀个参数,做进⼀步的处理如运算## annual_salary=max2(max2(3000,2000),3000) #将函数当做⼀个参数,传给函数做进⼀步的调⽤## print(annual_salary)# def foo():# print(1)# print(2)# print(3)# return [1,2,3],'a',('a','b'),{1,2} #return可以返回任意数据类型,返回多个值,函数遇到return整个函数就会结束# print(4)# print(5)# print(6)## res=foo()# print(res)# def bar():# print(1)# print(1)# print(1)# print(1)# return #return没有写返回值,默认返回值为None# print(2)# print(3)# print(4)## res=bar()# print(res)2、函数的调⽤'''1 什么是调⽤函数函数名(...)即调⽤函数,会执⾏函数体代码,直到碰到return结束或者⼀直运⾏完毕所有代码2 为何要调⽤函数⽤函数的功能3、函数调⽤分为三种形式max2(1,2) #直接调⽤函数res=max2(3000,2000) * 12 #当做参数做进⼀步处理res=max2(max2(1000,2000),3000) #当做函数的参数做进⼀步的调⽤'''# def foo():# print(1)# print(2)# print(3)# return None #None不写,默认就为None# res=foo()# print(res)def max2(x,y):if x > y:return xelse:return y# 调⽤函数的三种形式#形式⼀:# max2(1,2)#形式⼆:# res=max2(3000,2000) * 12# print(res)#形式三:res=max2(max2(1000,2000),3000)print(res)3、函数的参数#总的分类:# #1、形参:在函数定义阶段括号内定义的参数,称之为形式参数,简称形参,本质就是变量名# def foo(x,y): #x=1,y=2 #x、y本质就是变量名,也即形参# print(x)# print(y)# #2、实参:在函数调⽤阶段括号内传⼊的值,称之为实际参数,简称实参,本质就是变量的值# foo(1,2) #1、2本质就是变量的值##详细的分类:#⼀、位置参数:#位置形参:在函数定义阶段,按照从左到右的顺序依次定义的形参,称之为位置形参#特点:但凡是按照位置定义的形参,都必须被传值,多⼀个不⾏,少⼀个也不⾏----------多⼀个少⼀个均会报错# def foo(x,y):# print('x:',x)# print('y:',y)#位置实参:在函数调⽤阶段,按照从左到右的顺序依次定义的实参,称之为位置实参#特点:按照位置为对应的形参依次传值-----------调换位置传⼊的值也会发⽣变化,⽽关键字实参调换顺序就不会影响值的传⼊结果# foo(1,2) #------传⼊的结果是不⼀样的# foo(2,1)#⼆、关键字实参:在调⽤函数时,按照key=value的形式为指定的参数传值,称为关键字实参#特点:可以打破位置的限制,但仍能为指定的形参赋值---------即不会影响传⼊的结果# foo(y=2,x=1) #⼆者调换顺序并不会影响传⼊值得结果#注意:#1、可以混⽤位置实参与关键字实参,但位置实参必须放在关键字实参的前⾯# foo(1,y=2) #---------位置实参放在关键字参数的前⾯即左边# foo(y=2,1) #---------位置参数放在关键字参数的后⾯会报错,SyntaxError: positional argument follows keyword argument#2、可以混⽤,但不能对⼀个形参重复赋值# foo(1,y=2,x=10) #---------形参x被重复传值,所以会报错#三:默认参数:在函数定义阶段,就已经为形参赋值,该形参称为默认形参#特点:在定义阶段就已经被赋值,意味着在调⽤可以不⽤为其赋值# def foo(x,y=10): #---------形参有默认值,调⽤阶段,可以不⽤给其进⾏传值,会以默认参数为准,如给默认形参传值,则会以传⼊的值为准# print('x:',x)# print('y:',y)# foo(1) #y没有传值则会以默认的为准# foo(1,3) #默认形参也被重新传值,则会以传⼊的3为准# 注意:#1、位置形参必须放到默认形参的前⾯,否则报语法错误# def foo(x=1,y): #默认形参放在位置形参的前⾯会报错----SyntaxError: non-default argument follows default argument# pass#2、默认参数的值只在定义阶段赋值⼀次,即默认参数的值在函数定义阶段就已经固定死了# m=10# def foo(x=m,y=11):# print(x)# print(y)# m=111111111111111111111111111 #----------默认参数的值在定义阶段就已经固定死了,所以该m的是并不会影响调⽤的结果# foo()#3、默认参数的值通常应该定义不可变类型---------定以为可变类型,会产⽣耦合的现象# def register(name,hobby,hobbies=[]): #默认参数为可变类型,产⽣耦合现象# hobbies.append(hobby)# print('%s的爱好' %name,end=':')# print(hobbies)## register('egon','play') #egon的爱好:['play']# register('alex','piao') #alex的爱好:['play', 'piao']# register('lxx','烫头' ) #lxx的爱好:['play', 'piao', '烫头'],lxx只有烫头的爱好,⽽结果却继承了egon和alex的爱好# def register(name,hobby,hobbies=None):# if hobbies is None:# hobbies=[]# hobbies.append(hobby)# print('%s的爱好' %name,end=':')# print(hobbies)## register('egon','play')# register('alex','piao')# register('lxx','烫头')#总结:#实参的应⽤:取决于个⼈习惯,-------⾃⼰喜欢⽤哪种实参都可以为形参进⾏传值#形参的应⽤:#1、位置形参:⼤多数情况下的调⽤值都不⼀样,就应该将该参数定义成位置形参#2、默认形参:⼤多数情况下的调⽤值都⼀样,就应该将该参数定义成默认形参# def register(name,age,sex='male'): #⼈的性别⼤多数⼈都⼀样,所以设置为默认参数,不⽤每次调⽤都给其传值# print(name)# print(age)# print(sex)### register('egon',18,)# register('⼤脑门',73,'female') #设置默认参数的好处,调⽤时只需要给少数性别不⼀样的进⾏传值就可以了# register('⼩脑门',84,)# register('⼤⾼个',18,)#四:可变长参数:指的是在调⽤函数时,传⼊的参数个数可以不固定-------如计算⼏个数的和#⽽调⽤函数时,传值的⽅式⽆⾮两种,⼀种位置实参,另⼀种时关键字实参#所以对应着,形参也必须有两种解决⽅案,来分别接收溢出的位置实参(*)与关键字实参(**)#1、形参中某个参数带*#形参中的*会将溢出的位置实参全部接收,然后存储元组的形式,然后把元组赋值给*后的变量名# def foo(x,y,*z): #x=1,y=2,z=(3,4,5,6,7)-------*接收所有溢出的实参,并将其传承元组赋值给变量z# print(x)# print(y)# print(z)# foo(1,2,3,4,5,6,7)# 应⽤---------------计算若⼲个数的和# def my_sum(*nums): #-----*接收传进来的所有的位置实参,存成元组的形式# res=0 #运算的初始值为0# for num in nums: #for循环,将元组中所有的参数取出来,进⾏数学运算# res+=num #运算的结果返回给调⽤者# return res## print(my_sum(1,2,3,4,5)) #将溢出的所有值都让*接收# 2、实参中的参数也可以带*# 实参中带*,*会将该参数的值循环取出,打散成位置实参#ps:以后但凡碰到实参中带*的,它就是位置实参,应该⽴马打散成位置实参去看# def foo(x,y,z):# print(x,y,z)## foo(1,*[2,3]) #foo(1,2,3) #-----*将列表中的数循环取出,打散成位置参数,传给位置形参# foo(1,*'he') #foo(1,'h','e') #-----*将字符串中的字符循环取出,打散成位置参数,传给位置形参# foo(1,*(2,3,4)) #foo(1,2,3,4) #-----*将元组中的数循环取出,打散成位置参数,传给位置形参------但打散的位置实参超出位置形参的个数,所以会报错# def foo(x,y,z,*args):# print(x)# print(y)# print(z)# print(args) #打印结果:(4, 5, 6, 7, 8, 9, 10, 11)# ## foo(1,2,3,4,5,6,7,*[8,9,10,11]) #foo(1,2,3,4,5,6,7,8,9,10,11) #打散传给位置形参,溢出的将会被形参中的*接收,存成元组的形式#注意:约定俗成形参中的*变量名的写法都是:*args#1、形参中某个参数带**#形参中的**会将溢出的关键字实参全部接收,然后存储字典的形式,然后把字典赋值给**后的变量名# def foo(x,y,**z): #x=1,y=2,z={'c':5,'b':4,'a':3}------**会接收溢出的所有关键字实参,并将其存成字典的形式赋值给变量z# print(x)# print(y)# print(z) #打印结果:{'a': 3, 'b': 4, 'c': 5}# foo(1,2,a=3,b=4,c=5)# 2、实参中的参数也可以带**,该参数必须是字典# 实参中带**,**会将该参数的值循环取出,打散成关键字实参#ps:以后但凡碰到实参中带**的,它就是关键字实参,应该⽴马打散成关键字实参去看# def foo(x,y,z):# print(x)# print(y)# print(z)## foo(1,2,**{'a':1,'b':2,'c':3,'z':3}) #foo(1,2,c=3,b=2,a=1,z=3) #打散后的实参已经超过了形参能够接收读的个数,所以会报错# foo(**{'z':3,'x':1,'y':2}) #foo(y=2,x=1,z=3)-----**是实参中的字典打散成关键字参数#注意:约定俗成形参中的**变量名的写法都是:**kwargs# def index(name,age,sex):# print('welecome %s:%s:%s to index page' %(name,age,sex)) #------打印结果:welecome egon:18:male to index page## def wrapper(*args,**kwargs): #args=(1,),kwargs={'x': 1, 'y': 2, 'z': 3}# index(*args,**kwargs) #index(*(1,),**{'x': 1, 'y': 2, 'z': 3}) #index(1,x=1,y=2,z=3)## wrapper(name='egon',sex='male',age=18) #该关键字参数会原封不动的传给其内部的index函数,当做其实参,在原封不动的传给index函数的形参# ##五命名关键字形参:在函数定义阶段,*后⾯的参数都是命名关键字参数(**)# 特点:在传值时,必须按照key=value的传,并且key必须命名关键字参数指定的参数名# def register(x,y,z,**kwargs): #kwargs={'b':18,'a':'egon'}# if 'name' not in kwargs or 'age' not in kwargs:# print('⽤户名与年龄必须使⽤关键字的形式传值')# return# print(kwargs['name']) #关键字变量名是‘name’则会被打印,否则不会打印出来# print(kwargs['age'])# # register(1,2,3,a='egon',b=18) #关键字实参,会被**接收存储成字典的形式,并赋值给变量kwargs# register(1,2,3,name='egon',age=18) #关键字实参,会被**接收存储成字典的形式,并赋值给变量kwargs# def register(x,y,z,*args,name='egon',age): #命名关键字参数,*后⾯的形参,均为命名关键字参数,也意味着命名关键字参数,必须按照# print(args) #(4, 5, 6, 7)# print(name) #egon----------name='egon'在*后⾯也是命名关键字参数,并不是默认参数# print(age) #18# register(1,2,3,4,5,6,7,age=18)# register(1,2,3,4,5,6,7,c=18) #没有按照命名关键字进⾏传值,所以会报错-----TypeError: register() got an unexpected keyword argument 'c'## def foo(x,y=1,*args,z=1,a,b,**kwargs):# pass# def foo(x,*args,y=1,z=1,a,b,**kwargs):# pass# def foo(x,y=1,**kwargs,*args,z=1,a,b): #*后⾯为关键字参数,**相当于默认参数,⽽*相当于位置形参,⽽位置形参要放在默认参数的前⾯,所以会报错# pass# # foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) #foo(1,1,2,3,a=1,y=2,x=1) #将实参中的*和**打散成位置实参和关键字实参在进⾏传值# foo(1,a=1,*[1,2,3],**{'x':1,'y':2}) #foo(1,a=1,1,2,3,y=2,x= 1) #关键字参数a=1在*打散后位置参数的前⾯所以会报错# foo(1,2)# foo(x=1,y=2)# open('a.txt','w',encoding='utf-8') #Ctrl+⿏标左键,查看源代码可以看到如下,'a.txt'为位置实参,'w'为位置实参,默认的为位置形参mode='r',#按顺序传值,所以'utf-8'要指定为关键字实参#-----def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True):。

函数的参数与返回值.ppt

函数的参数与返回值.ppt
• 多维数组作为参数时,除第一维以外的所有 维数都必须写出
地址传递的特点
• 好处
– 节省栈空间 – 可以通过传递的地址间接修改实在参数
• 坏处
– 可能会对实在参数产生副作用 – 通过指针传递信息和访问信息不太直接
引用传递(引用参数)
符号表 para
0x3492034
125
void func1() {
– 一般数据类型 – 指针返回
Type func(......)
• 引用返回
Type & func(......);
返回值
int func(...) char * func(...) ClassA func(...) ClassA * func(...) ...
注意:要保证返回的指针指向合法空间
ClassA & func(...) int & func(...)
int localAA; } int funcA(int para1, int para2) {
int local1=1; funcAA(); return para1+para2+local1; } void main() { int a=2,b=3; funcA(a,b); }
函数的参数传递
操操操操localAA 操操paraAA
void func2(int inVar) {
inVar = 45; }
按值传递
• 简单数据类型、结构、对象都是按值传递
float f; SomeClass aObj; SomeStruct aStruct;
func(f); func构参数
• 类的对象作为参数传递时
for(int i=0; i < size; i++) A[i] = i;

第5章 函数与带参数宏 《C语言程序设计及应用教程》课件-PPT课件

第5章 函数与带参数宏  《C语言程序设计及应用教程》课件-PPT课件

5.2 函数的嵌套与递归调用
函数的嵌套调用
不允许嵌套定义,函数间平行的、独立。 C中的函数:
允许嵌套调用。
main( ) 调用函数a 结束
a函数
调用函数b
b函数
【例5-7】 输入两个整数,求平方和
#include <stdio.h>
int fun1(int x,int y)
int fun1(int x,int y);
斐波那契数列");
for(i=0;i<N;i++)
{
printf("%d\t",iF[i]);
if((i+1)%10==0)
printf("\n");
}
printf("\n");
}
int Sum(int iF[],int n); void main() { int i,Fibonacci[N],m,n; //生成斐波那契数列 CreateFibonacci(Fibonacci); //输出斐波那契数列 PrintFibonacci(Fibonacci); //求数列前n项的和 printf(" 请输入要求和的项数 n(n<%d): ",N); scanf("%d",&n); m=Sum(Fibonacci,n); printf("\n 斐波那契数列前 %d项的和:%4d\n",n,m);}
第5章 函数与带参数宏 ?C语言 程序设计及应用教程?课件
5.1 函数的声明、定义与调用
5.1.1 函数的声明与定义 5.1.2 函数调用 5.1.3 函数参数传递 5.1.4 主函数中的参数

Python课件PPT:第6章 函数

Python课件PPT:第6章 函数

6.9.2 利用递归函数解决汉诺塔问题
6.9.3 防止栈溢出
使用递归函数需要注意防止栈溢出。在计算 机中,函数调用是通过栈(stack)这种数 据结构实现的,每当进入一个函数调用,栈 就会加一层栈帧,每当函数返回,栈就会减 一层栈帧。由于栈的大小不是无限的,所以 ,递归调用的次数过多,会导致栈溢出。
6.10 匿名函数
所谓匿名,即不再使用def语句这样标准的形式定义一 个函数。Python使用lambda创建一个匿名函数。
下面举个简单的例子。定义一个返回参数之和的函数。 def f(x,y): return x+y 用户的函数只有一个表达式,就可以使用lambda运算
符来定义这个函数。 f = lambda x, y: x + y
6.6 形参和实参
函数的参数分为形参和实参两种。形参出现 在函数定义中,在整个函数体内都可以使用 ,离开该函数则不能使用;实参再调用函数 时传入。
1. 形参与实参的概念 2. 参数的功能 3. 形参和实参的特点:
6.7 变量作用域
在函数之外定义的变量属于全局变量,用户 可以在函数内使用全局变量。例如:
>>>m = f1(-100,abs)
>>>m()
#需要对m()调用才能得到求绝对值的结果
6.9 递归函数
6.9.1 使用递归函数 6.9.2 利用递归函数解决汉诺塔问题 6.9.3 防止栈溢出
6.9.1 使用递归函数
递归是指在函数的执行过程中再次对自己进 行调用。例如:
def f() { y=f(); return y; }
6.4.2 关键字参数
用户可以直接设置参数的名称与其默认值,这种类型的参数属于 关键字参数。

11函数参数的传递和值返回

11函数参数的传递和值返回

前面我们说的都是无参数无返回值的函数,实际程序中,我们经常使用到带参数有返回值的函数。

一、函数参数传递1.形式参数和实际参数函数的调用值把一些表达式作为参数传递给函数。

函数定义中的参数是形式参数,函数的调用者提供给函数的参数叫实际参数。

在函数调用之前,实际参数的值将被拷贝到这些形式参数中。

2.参数传递先看一个例子:void a(int); /*注意函数声明的形式*/main(){int num;scanf(%d,&num);a(num); /*注意调用形式*/}void a(int num_back) /*注意定义形式*/{printf(%d\n,num_back);}在主函数中,先定义一个变量,然后输入一个值,在a()这个函数中输出。

当程序运行a(num);这一步时,把num的值赋值给num_back,在运行程序过程中,把实际参数的值传给形式参数,这就是函数参数的传递。

形参和实参可能不只一个,如果多于一个时,函数声明、调用、定义的形式都要一一对应,不仅个数要对应,参数的数据类型也要对应。

void a(int,float);main(){int num1;float num2;scanf(%d,&num1);scanf(%f,&num2);a(num1,num2);}void a(int num1_back,float num2_back){printf(%d,%f\n,num1_back,num2_back);}上面的例子中,函数有两个参数,一个是整型,一个是浮点型,那么在声明、调用、定义的时候,不仅个数要一样,类型也要对应。

如果不对应,有可能使的编译错误,即使没错误,也有可能让数据传递过程中出现错误。

再看一个例子:void a(int);main(){int num;scanf(%d,&num);a(num);}void a(int num){printf(%d\n,num);}看上面的例子,形式参数和实际参数的标识符都是num,程序把实际参数num的值传递给形式参数num。

函数的参数与返回值

函数的参数与返回值

函数的参数与返回值函数是一种封装了一组相关代码的可重用模块,它可以接收一些输入参数并返回一个结果。

参数是函数的输入,而返回值是函数的输出。

在本文中,我将探讨函数的参数和返回值的相关内容,并且将重点介绍一些关于参数和返回值的特殊用法和最佳实践。

1.函数参数的类型函数参数可以分为四种类型:必需参数、关键字参数、默认参数和不定长参数。

1.1必需参数必需参数是指函数在调用时必须提供的参数,否则会引发错误。

函数在定义时可以指定参数的名称和数据类型,当调用该函数时,传入的参数必须按照指定的顺序和类型进行传递。

例如,我们定义一个计算两个数之和的函数:```pythondef add(x, y):return x + y```在这个例子中,x和y是必需参数,调用函数时必须按照顺序传递两个参数,否则会引发TypeError异常。

1.2关键字参数关键字参数是指在调用函数时通过参数名来传递参数的方式。

通过关键字参数,可以不需要按照函数定义时的顺序传递参数,提高了函数的可读性。

例如,我们定义一个函数来打印一个人的信息:```pythondef print_info(name, age, gender):print("Name:", name)print("Age:", age)print("Gender:", gender)```可以使用关键字参数来调用该函数,如下所示:```pythonprint_info(name="John", age=25, gender="Male")```在这个例子中,我们指定了参数的名称并传递了相应的值,函数会根据参数名来匹配传递的值,而不是按照顺序匹配。

1.3默认参数默认参数是指在定义函数时给参数设定一个默认值,这样在调用函数时可以不传递该参数的值。

如果调用函数时没有提供默认参数的值,函数会使用默认值作为参数的值。

C++std::thread调用带参数和返回值的函数

C++std::thread调用带参数和返回值的函数

C++std::thread调⽤带参数和返回值的函数⼀、线程调⽤的函数含有参数多线程中的函数参数如果为引⽤必须使⽤std::ref(函数式编程的参数默认使⽤拷贝⽅式),多线程中的函数参数如果为IO(socket应该也需要,没有测试过)必须使⽤移动语义(std::move),避免多个对象同时读写同⼀个IO缓冲点击查看代码⼆、线程调⽤成员函数点击查看代码三、多线程执⾏含有返回值的函数,获取函数返回值1.将函数的返回值设置为输出参数2.使⽤lambda表达式获取函数返回值点击查看代码3.使⽤std::future、std::promise和packaged_taskstd::async和std::future的使⽤std::async()与std::thread()最明显的不同就是async只是创建异步任务,不⼀定创建线程。

async()默认创建线程,可以设置第⼀个参数来决定是否创建线程。

async函数原型点击查看代码std::promise和std::future的使⽤promise作为参数应该以引⽤的形式传⼊(),因此需要使⽤future和promise的作⽤是在不同线程之间传递数据。

使⽤指针也可以完成数据的传递,但是指针⾮常危险,因为互斥量不能阻⽌指针的访问;⽽且指针的⽅式传递的数据是固定的,如果更改数据类型,那么还需要更改有关的接⼝,⽐较⿇烦;promise⽀持泛型的操作,更加⽅便编程处理。

std::promise的作⽤就是提供⼀个不同线程之间的数据同步机制,它可以存储⼀个某种类型的值,并将其传递给对应的future,即使这个future不在同⼀个线程中也可以安全的访问到这个值。

点击查看代码std::packaged_task和std::future的使⽤std::packaged_task的作⽤就是提供⼀个不同线程之间的数据同步机制,std::packaged_task本⾝和线程没有关系,它只是关联了⼀个std::future的仿函数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
double area; //定义面积变量 //根据radius计算圆的面积 area = 3.14 * radius * radius ; //返回圆的面积 return area; }
有返回值有参数函数的编写
编写中注意的问题:
(1)不允许再次定义与参数名相同的变量 (2)参数的值是不需要在函数中输入的(因为是在调用的时 候传递过来的) (3)在函数中一般不输出结果 (4)函数要结束的位置必须用 return语句返回正确的值。 return 语句的格式为:
//第一步:定义变量(用于输入运算数和保存结果) //第二步:从键盘上输入两个运算数 //第三步:计算两个数的除法(要用if语句考虑除数为0的特殊情况) //第四步:输出计算结果
}
无返回值无参数函数的调用
假设在main函数中调用。在其他函数中调用也是一样 的。 main() {
divide( ); //函数调用语句(直接调用) }
return 表达式(或常量值); 该表达式的值 应该与 返回值的类型一致,否则程序就存在 缺陷。
有返回值有参数函数的编写
练习:根据三角形的三条边来计算其面积,并将面积返回。
计算公式 area s(s a)(s b)(s c)
为:
,其中
s=(a+b+c)/2。
函数定义如下:
double areaOfTriangle( double a, double b, double c) //a,b,c分别表示三边 {
– int、float、double、char – scanf、printf、(getchar、 putchar) – 算术、赋值、关系、逻辑运算符
• 三种程序设计结构
– 顺序、选择(分支)、循环 结构
第1学期计算器案例主要内容
• 用无参无返回值的函数实现 • 加、减、乘运算----顺序结构 • 除法、求余----分支结构(判断除数是否为0) • 累加、阶乘----循环结构
返回值类型有:void、int、double、float、char及其他C语 言中可以使用的类型。
如果是void表示该函数无返回值。其他则表示有返回值。参 数类型即是数据类型、参数名即是变量名,只是叫法不同而 已。
函数的类型
由返回值和参数是否有可构成以下四类函数:
类型 (1)无返回值无参数函数 (2)无返回值带参数函数 (3)有返回值无参数函数 (4)有返回值带参数函数**
• 主函数----switch语句的应用、用死循环控制 程序反复执行
本课内容
• 带式:
返回值类型 函数名(参数类型 参数名)
注:也可以没有参数或有两个(以上)的参数,两个以上的参数用逗号分隔,如:
返回值类型 函数名(参数类型 参数名,参数类型 参数名, 参数类型 参数名)----这是有三个参数的函数
declaration local variable
函数 实际参数 形式参数 返回值 函数原型声明
局部(定义在函数内部的)变量
回顾与提问
1. 简单回顾第1学期的主要内容 2. 回顾第1学期计算器案例的主要内容
第1学期主要内容
• C语言程序结构
– (无参无返回值函数的编写)
• 数据类型、变量输入/输出、运算符
double areaOfCircle( double radius ) //radius表示半径 {
//根据radius计算圆的面积 //返回圆的面积 }
有返回值有参数函数的编写
例1:如果我们想定义一个函数,要求该函数能够实现计算圆 的面积,并将计算结果返回,则可将函数定义如下:
double areaOfCircle( double radius ) //radius表示半径 {
有返回值有参数函数的编写思路
与无返回值无参数函数略有不同。
返回值的数据类型 函数名(数据类型 参数名1 , 数据类型 {
//函数的功能代码部分----略有不同 //返回结果值—--最大的不同之处 }
参数名2)
有返回值有参数函数的编写
例1:如果我们想定义一个函数,要求该函数能够实现计算圆 的面积,并将计算结果返回,则可将函数定义如下:
有返回值有参数函数的调用
假设在main函数中进行调用areaOfCircle :
main( ) {
double r; double result; //定义变量 scanf( “%lf” , &r); //输入实际参数的值 result = areaOfCircle( r ); //调用函数 printf(“面积为:%lf\n” , result );//输出结果 }
带参带返回值函数
• 复习 • 自定义函数的分类 • 自定义函数的声明、调用、编写 • 带参带返回值函数的应用 • 课堂练习 • 课堂小结 • 本节对应教材:P198-216
专业英语词汇
英文词汇
对应的中文意义
function arguments formal parameters return value function prototype
函数原型举例 void f1( ); void f2(char s ); int f3( ); double f4( int n );
实际编程中,各种类型都可能遇到,但最常见的是有返回值 带参数的函数
无返回值无参数函数的编写思路
与在main函数中编程思路完全相同。 例如:计算器中的除法函数 void divide( ) {
//根据三边计算三角形面积 //返回三角形面积 }
有返回值有参数函数的调用
假设在main函数中进行调用:思路如下
(1)定义与被调用函数参数个数相同,且类型对应相同的变 量 (2)定义与被调用函数返回值类型一致的一个变量,用以保 存调用后的结果 (3)为每个实际参数赋值 (4)调用函数,并保存函数返回的结果 (5)输出结果(或用结果进行其他运算)
有返回值有参数函数的调用
result = areaOfCircle( r ); //调用函数
main( ) {
//…调用前的代码 result = areaOfCircle( //…调用后的代码 }
r );
//调用时
double {
果值 }
areaOfCircle( double radius)
相关文档
最新文档