将＂引用＂作为函数返回值类型的格式、好处和需要遵守的规则.doc
返回值的使用方法
返回值的使用方法
返回值的使用方法：
返回值是函数执行后返回给调用者的结果，也就是函数的执行结果。
在程序设计中，返回值的使用方法非常重要。
正确使用返回值可以提高程序的效率，减少
程序出错的可能性，也可以方便代码的调试和维护。
要使用函数的返回值，可以将函数的返回值保存在一个变量中，然后对该变量进行操作。
对于返回值为基本数据类型（如整型、浮点型等）的函数，可以直接将返回值保存在变量中。
对于返回值为引用类型（如数组、对象等）的函数，则需
要将返回值保存在相应的引用类型变量中。
在使用返回值时，需要注意以下几点：
1. 返回值的类型应该与函数声明时指定的类型相同或兼容。
2. 如果函数返回值为引用类型，需要注意返回值的有效性和生命周期，避免出现野指针或内存泄漏等问题。
3. 如果函数返回值为结构体或类对象，需要按照相应的使用方法来操作该对象，避免出现不必要的副本和浪费。
总之，返回值是函数的执行结果，正确使用函数的返回值可以提高程序的效率和可维护性，避免程序出错。
在使用返回值时，需要注意返回值的类型、有效性和生命周期等问题。
函数的返回值、函数的调用、函数的参数
函数的返回值、函数的调⽤、函数的参数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):。
函数的引用技巧
函数的引用技巧函数的引用技巧是指在编程中，使用函数的名称作为一个值来传递，以便在其他地方重用该函数的代码。
函数引用技巧可以提高代码的可读性和可维护性，减少重复代码的编写，提高代码复用性。
以下是一些常见的函数引用技巧：1. 将函数作为参数传递：在很多编程语言中，函数可以作为参数传递给其他函数。
这种做法可以增加代码的灵活性，使得代码可扩展性更强。
例如，在排序算法中，可以将比较函数作为参数传递给排序函数，实现按照不同的规则进行排序。
2. 将函数作为返回值：函数也可以作为另一个函数的返回值。
这种技巧常用于创建一些工厂函数，根据不同的条件返回不同的函数。
例如，一个计算器程序可以根据用户的输入返回不同的计算函数，实现不同的计算功能。
3. 函数的封装和组合：多个函数可以组合成一个更复杂的函数，实现更高层次的功能。
这种做法可以提高代码的可读性和可维护性，减少重复代码的编写。
例如，可以将一系列的数据处理函数封装成一个数据处理函数，以进行统一的数据处理操作。
4. 函数的继承和重写：在面向对象的编程中，子类可以引用父类的函数，实现代码的复用。
子类可以重写父类的函数，根据需要修改函数的实现，实现更具体的功能。
这种技巧可以增加代码的可扩展性和灵活性。
5. 函数的闭包：闭包是一种特殊的函数引用技巧，可以创建一个函数和其相关的环境变量的组合。
闭包可以实现类似于对象的功能，可以保存函数的状态和数据。
这种技巧常用于创建一些有状态的函数，如计数器、缓存等。
6. 函数的装饰器：装饰器是一种使用函数来修改其他函数行为的技巧。
装饰器可以在不修改原函数代码的情况下，增加一些额外的功能。
常见的装饰器有日志记录、性能统计等。
装饰器是一种灵活和强大的技巧，可以提高代码的可读性和可维护性。
7. 函数的模块化和命名空间：在大型项目中，可以将函数按照功能模块划分，并放置在不同的文件或者包中。
这样做可以提高代码的可维护性和可复用性。
同时，在各个模块中可以使用命名空间来避免函数名称的冲突。
引用作为函数返回值
引用作为函数返回值
一、引用作为函数返回值
引用作为函数返回值是指函数的返回类型是引用。
它返回的是一个指向外部变量的引用，使外部变量与函数名作用范围一致。
以下是一个典型的引用作为函数返回值的例子：
int & add(int &a,int &b) //函数返回值是引用
{
return a+b;
}
二、好处
1、引用作为函数返回值可以减少中间变量带来的开销，从而提高程序的效率。
因为函数的返回类型是引用，它返回的就是函数体重的变量的引用，而不是拷贝出来的一个新的变量，这样就可以避免大量的中间变量，使程序的效率更高。
2、引用作为函数返回值可以减少函数调用链，这样就提高程序的可读性。
因为函数的返回类型是引用，它返回的就是函数体内的变量，而不是拷贝出来的一个新的变量，所以可以避免多次函数调用，从而提高程序的可读性。
三、缺点
1、引用作为函数返回值易混淆，调试比较困难。
因为多个函数之间的变量作用范围具有可能合并或重叠，所以在调试过程中容易混
淆，从而导致错误。
2、引用作为函数返回值受限制，不能直接返回局部变量的引用.因为局部变量在函数调用结束后就会被释放，所以不能直接返回局部变量的引用。
函数的参数传递与返回值的注意事项
函数的参数传递与返回值的注意事项在电脑编程中，函数是一种非常重要的工具，它可以帮助我们组织代码，提高代码的可读性和可维护性。
在编写函数时，我们需要注意函数的参数传递和返回值的使用，以确保代码的正确性和效率。
本文将探讨函数的参数传递与返回值的一些注意事项。
1. 值传递与引用传递在函数调用过程中，参数可以通过值传递或引用传递的方式传递给函数。
值传递是指将参数的值复制给函数的形参，而引用传递是指将参数的引用传递给函数的形参。
当使用值传递时，函数内部对形参的修改不会影响到原始参数的值。
这是因为函数在栈上创建了一个新的变量来存储形参的值，而不是直接修改原始参数。
这种方式适用于简单的数据类型，如整数、浮点数等。
当使用引用传递时，函数内部对形参的修改会影响到原始参数的值。
这是因为函数使用原始参数的内存地址来访问和修改参数的值。
这种方式适用于复杂的数据类型，如数组、结构体等。
在选择参数传递方式时，需要根据函数的需求和数据类型的特点进行选择。
如果函数需要修改参数的值，或者参数是复杂的数据类型，那么应该使用引用传递。
如果函数不需要修改参数的值，或者参数是简单的数据类型，那么可以使用值传递。
2. 返回值的类型和范围在函数的定义中，我们可以指定函数的返回值类型。
返回值是函数执行完毕后返回给调用者的结果。
在选择返回值的类型时，需要根据函数的需求和返回结果的特点进行选择。
返回值的类型可以是任意的数据类型，包括整数、浮点数、布尔值、字符串等。
需要根据函数的计算结果来选择返回值的类型。
例如，如果函数需要返回一个整数计算结果，那么返回值的类型应该是整数类型。
在函数的执行过程中，可以使用return语句来返回函数的结果。
return语句将函数的执行结果返回给调用者，并结束函数的执行。
在使用return语句时，需要确保返回值的类型和范围与函数的定义相匹配，以避免出现错误或异常。
3. 异常处理和错误返回值在函数的执行过程中，可能会发生错误或异常情况。
用引用返回值
第六节用引用返回值函数返回值时，要生成一个值的副本。
而用引用返回值时，不生成值的副本。
例如，下面的程序是有关引用返回的4种形式：//*********************//** ch9_6.cpp **//*********************#include <iostream.h>float temp;float fn1(float r){temp = r*r*3.14;return temp;}float& fn2(float r){temp = r*r*3.14;return temp;}void main(){float a=fn1(5.0); //1float& b=fn1(5.0); //2:warningfloat c=fn2(5.0); //3float& d=fn2(5.0); //4cout<<a<<endl;cout<<b<<endl;cout<<c<<endl;cout<<d<<endl;}运行结果为：78．578．578．578．5对主函数的4种引用返回的形式，程序的运行结果是一样的。
但是它们在内存中的活动情况是各不相同的。
其中变量temp是全局数据，驻留在全局数据区data。
函数main()、函数fnl()或函数fn2()驻留在栈区stack。
第一种情况：见图9-5。
图9-5 返回值方式的内存布局这种情况是一般的函数返回值方式。
返回全局变量temp值时，C++创建临时变量并将temp的值78.5复制给该临时变量。
返回到主函数后，赋值语句a=fnl(5.0)把临时变量的值78.5复制给a。
第二种情况：见图9-6。
图9-6 返回值初始引用的情形这种情况下，函数fnl()是以值方式返回的，返回时，复制temp的值给临时变量。
返回到主函数后，引用b以该临时变量来初始化，使得b成为该临时变量的别名。
函数中的返回值
函数中的返回值【原创版】目录1.函数的定义和作用2.返回值的概念和分类3.返回值的使用方法4.返回值在函数中的重要性5.返回值在实际编程中的应用案例正文在编程语言中，函数是一种可以实现特定功能的代码块，它由一系列语句组成，并能够接受输入参数。
函数在执行完毕后，通常需要返回一个结果，这个结果就是所谓的返回值。
本文将详细介绍返回值在函数中的相关知识。
首先，让我们了解一下函数的定义和作用。
函数是一种高级编程结构，用于封装一段可重复使用的代码。
通过调用函数，可以避免代码重复，提高程序的可读性和可维护性。
函数在执行过程中，可以接收输入参数，进行相应的操作，最后返回一个结果。
接下来，我们来探讨返回值的概念和分类。
返回值是函数执行完毕后返回给调用者的结果。
根据返回值的类型，可以分为数值型、字符串型、布尔型、对象型等。
不同类型的返回值在编程中有着不同的应用场景。
在了解了返回值的概念后，我们需要掌握返回值的使用方法。
在函数体内，可以通过特定的语法结构返回一个值。
在 Python 中，使用`return`关键字来返回一个值；在 JavaScript 中，则使用`return`语句。
需要注意的是，返回值需要符合函数定义时的类型，否则会报错。
返回值在函数中的重要性不言而喻。
它使得函数能够将计算结果传递给调用者，实现代码的复用。
同时，返回值也是函数接口的一部分，决定了函数的输出行为。
因此，在编写函数时，需要合理设计返回值，以满足程序的需求。
最后，我们来看一个返回值在实际编程中的应用案例。
假设我们需要编写一个计算两个数之和的函数，可以使用以下 Python 代码：```pythondef add(a, b):result = a + breturn resultsum = add(3, 4)print(sum) # 输出：7```在这个例子中，`add`函数接收两个参数`a`和`b`，计算它们的和，并将结果返回给调用者。
通过使用返回值，我们实现了函数的功能，并使得代码更加简洁易懂。
将“引用”作为函数返回值类型的格式、好处和需要遵守的规则
好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtimБайду номын сангаас error!
注意事项：
（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。
（3）可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。
（2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。
（4）流操作符重载返回值申明为“引用”的作用：
流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl; 因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。
c++函数返回值、引用
c++函数返回值、引⽤c++ 函数返回引⽤⼀，c++函数的返回分为以下⼏种情况1）主函数main的返回值：这⾥提及⼀点，返回0表⽰程序运⾏成功。
2）返回⾮引⽤类型：函数的返回值⽤于初始化在跳⽤函数出创建的临时对象。
⽤函数返回值初始化临时对象与⽤实参初始化形参的⽅法是⼀样的。
如果返回类型不是引⽤，在调⽤函数的地⽅会将函数返回值复制给临时对象。
且其返回值既可以是局部对象，也可以是求解表达式的结果。
3）返回引⽤：当函数返回引⽤类型时，没有复制返回值。
相反，返回的是对象本⾝。
⼆，函数返回引⽤1，当函数返回引⽤类型时，没有复制返回值。
相反，返回的是对象本⾝。
先看两⽰例，⽰例1如下：const string &shorterString(const string &s1,const string &s2) { return s1.size < s2.size ? s1:s2; }复制代码⽰例2：View Code1 ostream &operator<<(ostream &output, const AAA &aaa)2 {3 output << aaa.x << ' ' << aaa.y << ' ' << aaa.z << endl;4 return output;5 }复制代码形参和返回类型都是指向const string对象的引⽤，调⽤函数和返回结果时，都没有复制这些string对象。
2，返回引⽤，要求在函数的参数中，包含有以引⽤⽅式或指针⽅式存在的，需要被返回的参数。
⽐如：View Code1 int& abc(int a, int b, int c, int& result){23 result = a + b + c;4 return result;5 }67 这种形式也可改写为：89 int& abc(int a, int b, int c, int *result){10 *result = a + b + c;11 return *result;12 }复制代码但是，如下的形式是不可以的：View Code1 int& abc(int a, int b, int c){2 return a + b + c;3 }复制代码3，千万不要返回局部对象的引⽤。
excel引用函数格式
excel引用函数格式Excel引用函数格式Excel是一款功能强大的电子表格软件，广泛应用于办公和数据分析领域。
它提供了许多强大的函数来处理和分析数据。
其中，引用函数是Excel中最常用和最重要的函数之一。
引用函数可以用于引用单元格、范围或其他工作表中的数据，使得在计算和分析数据时更加灵活和高效。
在本文中，我们将介绍Excel引用函数的格式，并逐步回答与之相关的问题。
引用函数的格式如下：函数名（参数1，参数2，...）- 函数名：函数名用于指定要使用的具体函数，例如SUM、AVERAGE 等。
- 参数1，参数2，...：参数用于指定要引用的单元格、范围或其他工作表的位置。
现在，让我们一步一步回答以下问题，以进一步了解引用函数的格式和用法。
问题1：如何使用引用函数引用单个单元格？要使用引用函数引用单个单元格，只需在函数中指定单元格的位置。
例如，要引用单元格A1的值，可以使用如下的引用函数：= A1这个函数将返回单元格A1的值。
问题2：如何使用引用函数引用单元格范围？要使用引用函数引用单元格范围，可以通过指定范围的起始单元格和结束单元格来实现。
例如，要引用从A1到A10的单元格范围的值，可以使用如下的引用函数：= A1:A10这个函数将返回A1到A10范围内的所有单元格的值。
问题3：如何在引用函数中使用其他工作表的数据？要在引用函数中使用其他工作表的数据，需要在引用函数中指定其他工作表的名称和单元格位置。
例如，要引用名为“Sheet2”的工作表中单元格A1的值，可以使用如下的引用函数：= Sheet2!A1这个函数将返回“Sheet2”工作表中单元格A1的值。
问题4：引用函数中可以包含其他函数吗？是的，引用函数中可以包含其他函数。
这样做可以对引用的数据进行进一步的操作和计算。
例如，要求从A1到A10范围内值的总和，可以使用SUM函数来计算。
引用函数的格式如下：= SUM(A1:A10)这个函数将返回A1到A10范围内值的总和。
函数返回常引用
函数返回常引用当我们在编写函数时，我们通常会遇到需要返回某个对象的情况。
当对象非常大时，返回一个完整的对象可能会导致性能问题，因为需要复制整个对象。
此时，我们可以考虑返回对象的引用，以避免复制大量的数据。
但是，有些情况下，我们不希望返回的引用被修改。
比如，我们可能希望将一个对象信息传给其他函数，但不希望其他函数修改该对象的内容。
此时，我们可以返回一个常引用。
常引用是指引用一个不可修改的变量或对象的引用。
使用常引用的好处是可以避免对原对象的修改，从而保证程序的安全性和稳定性。
常引用可以用 const 关键字来修饰引用变量。
例如：```cppconst int& a = 10;```上述代码中，a 是一个常引用，引用一个 rvalue，即一个临时对象。
由于 a 是一个常引用，因此无法通过 a 来修改该临时对象的值。
在函数中返回常引用，可以使用以下语法：```cppconst ObjectType& functionName(parameters);```其中，ObjectType 是返回类型，functionName 是函数名，parameters 是函数参数列表。
函数返回一个常引用，引用一个名为 ObjectType 的对象。
常引用可以作为函数的返回值，具有以下几个方面的优点：1. 提高程序性能2. 保证程序的安全性由于常引用是只读的，返回常引用可以保证程序的安全性。
在某些情况下，我们不希望其他函数修改该对象的内容，此时可以返回一个常引用来保证程序的稳定性和健壮性。
3. 提高代码可读性返回常引用可以使代码更加简洁和易于理解。
常引用告诉读者该函数不会修改该对象的内容，并且可以避免对对象进行无谓的复制。
4. 方便代码的调用和维护常引用不仅可以作为函数的返回值，还可以作为函数的参数，方便代码的调用和维护。
常引用可以充当传递参数的方式，避免复制大型对象，进一步提高程序的性能。
在实际编程中，通常会使用常引用返回对象的成员变量。
C“引用作为参数”和“引用作为返回值”用法总结
C++“引用作为参数”和“引用作为返回值”用法总结标签：函数p1 fl oat 参数返回一、引用作为函数参数作为函数参数时引用有两种原因：在函数内部会对此参数进行修改提高函数调用和运行效率关于第一点，都知道C++里提到函数就会提到形参和实参。
如果函数的参数实质就是形参，不过这个形参的作用域只是在函数体内部，也就是说实参和形参是两个不同的东西，要想形参代替实参，肯定有一个值的传递。
函数调用时，值的传递机制是通过“形参=实参”来对形参赋值达到传值目的，产生了一个实参的副本。
即使函数内部有对参数的修改，也只是针对形参，也就是那个副本，实参不会有任何更改。
函数一旦结束，形参生命也宣告终结，做出的修改一样没对任何变量产生影响。
例如：void swap(intp1, i nt p2) //对两个变量进行交换处理。
此处函数的形参为p1, p2，没有引用{int p; p=p1;p1=p2; p2=p; }voidmain( ){i nt a,b;ci n>>a>>b; //输入a,b两变量的值swa p(a,b); //直接以变量a和b作为实参调用s wap函数cout<<a<< ' '<<b;//输出结果你会发现输出的a和b还是你输入的值，没有交换。
如果我们改为：void swap(int&p1,int &p2) //对两个变量进行交换处理。
此处函数的形参为p1,p2都是引用{ i nt p; p=p1; p1=p2; p2=p;}再次执行，就会发现值交换了。
函数中的返回值
函数中的返回值摘要：一、函数返回值的概念二、函数返回值的类型三、函数返回值的用途四、函数返回值的注意事项五、总结正文：【一、函数返回值的概念】在编程中，函数是实现特定功能的一段代码。
当函数执行完毕后，它可能会返回一个值，这个值被称为函数的返回值。
返回值可以用来表示函数执行的结果，或者作为其他函数的输入参数。
【二、函数返回值的类型】函数返回值的类型取决于编程语言和函数的具体实现。
一般来说，函数返回值可以是以下几种类型：1.整数（int）2.浮点数（float）3.字符串（string）4.布尔值（bool）5.空值（null）6.对象（object）7.数组（array）【三、函数返回值的用途】函数返回值可以用于以下场景：1.输出函数执行结果：某些函数的目的是计算出一个值，并将这个值返回给调用者。
例如，计算两个数的和、求一个字符串的长度等。
2.作为其他函数的输入参数：当一个函数需要使用其他函数的结果作为输入时，可以通过返回值来实现。
例如，一个函数需要对一个数组进行排序，它可以通过调用另一个排序函数并接收其返回值来实现。
3.控制程序流程：函数返回值还可以用于控制程序的执行流程。
例如，通过判断一个函数的返回值，可以决定是否继续执行某些代码块。
【四、函数返回值的注意事项】1.返回值应具有明确的意义：函数的返回值应能够清晰地表达函数执行的结果，以便于调用者理解和处理。
2.避免返回无关的值：函数应仅返回与函数功能相关的值，避免返回无关的值，以降低程序的复杂性和提高代码的可读性。
3.遵循编程语言的返回值规范：不同的编程语言可能有不同的返回值规范，函数应遵循相应的规范来提高代码的可移植性。
【五、总结】函数返回值是编程中一个重要的概念，它在实现函数功能、控制程序流程等方面发挥着重要作用。
将＂引用＂作为函数参数有哪些特点
将＂引用＂作为函数参数有哪些特点引用作为函数参数有以下几个特点：1.经典应用：引用作为函数参数主要用于传递参数的引用而非值。
通过传递引用，可以直接在函数内部对原始变量进行操作，避免了值传递的开销以及对原始变量进行拷贝的不必要操作。
2.原始变量的直接修改：通过引用作为函数参数，可以直接修改原始变量的值。
这对于需要在函数中修改外部变量的情况非常有用，避免了通过返回值再进行赋值的麻烦。
3.函数的返回值：引用作为函数参数可以用于返回一个函数的结果，在一些需要返回多个值的情况下非常方便。
通过引用返回结果，可以避免函数返回多个值时使用元组或结构体的复杂性。
4.内存效率：通过引用作为函数参数，可以避免进行变量的拷贝操作，节省了内存的使用。
特别是当传递大型对象或数据结构时，引用可以提高程序的性能和效率。
5.引用的可读性：通过引用作为函数参数，可以提高代码的可读性。
在函数调用时，通过传递引用可以清晰地告诉读者该函数会对传递的变量进行修改，而不需要深入函数内部来查看代码。
6.实现多态：通过引用作为函数参数，可以实现多态的效果。
当传递一个基类类型的引用时，函数可以接受任何派生类对象的引用作为参数，实现了代码的灵活性和可扩展性。
7.避免拷贝构造函数的调用：对于那些不支持拷贝构造函数的对象，或者由于性能原因不希望调用拷贝构造函数的情况，通过引用作为参数可以实现直接修改对象的目的，而不需要通过拷贝构造函数来创建对象的副本。
8.注意事项：使用引用作为函数参数时需要注意引用的有效性。
如果函数中使用了已经失效或释放的引用，会导致未定义的行为和错误。
因此，在使用引用作为函数参数时，需要确保传递的引用是有效的，并且在函数内部合理处理引用的生命周期。
总结来说，引用作为函数参数具有实时修改原始变量值、提高程序性能和内存效率、代码可读性好以及实现多态等特点。
但是在使用时需要注意引用的有效性，以避免出现未定义的行为和错误。
excel返回引用的函数
excel返回引用的函数【最新版】目录1.函数的定义和作用2.Excel 中的返回引用函数3.返回引用函数的实例和应用4.返回引用函数的优缺点5.结论正文在数学和编程领域，函数是一种将一组输入值映射到一组输出值的关系。
在 Excel 中，函数也是一种强大的工具，它可以帮助用户快速地完成各种复杂的计算和数据处理任务。
Excel 中的返回引用函数，是一种能够返回某个单元格或区域引用的函数。
这种函数在 Excel 中非常常用，它可以帮助用户实现各种复杂的数据操作和分析。
例如，Excel 中的 IF 函数就是一种返回引用函数。
它可以根据某个条件，返回不同的结果。
假设我们有一个表格，其中包含了学生的姓名和成绩，我们可以使用 IF 函数来判断某个学生的成绩是否及格。
如果成绩大于等于 60 分，则显示“及格”，否则显示“不及格”。
除了 IF 函数外，Excel 中还有很多其他的返回引用函数，例如VLOOKUP、INDEX、MATCH 等。
这些函数可以根据不同的条件和需求，实现各种复杂的数据操作和分析。
返回引用函数在 Excel 中有着广泛的应用。
它可以帮助用户快速地完成各种复杂的计算和数据处理任务，提高工作效率。
同时，返回引用函数也可以帮助用户实现各种复杂的数据分析和决策，提高数据的价值。
尽管返回引用函数在 Excel 中非常强大，但是它也存在一些缺点。
首先，返回引用函数的使用需要用户具备一定的 Excel 技能和知识，否则可能会出现错误。
其次，返回引用函数的运算过程比较复杂，可能会导致计算速度变慢。
总的来说，返回引用函数是 Excel 中的一种重要工具，它可以帮助用户快速地完成各种复杂的计算和数据处理任务。
C++常见面试题30道
C++常见⾯试题30道1.new、delete、malloc、free关系delete会调⽤对象的析构函数,和new对应free只会释放内存，new调⽤构造函数。
malloc与free是C++/C语⾔的标准库函数，new/delete是C++的运算符。
它们都可⽤于申请动态内存和释放内存。
对于⾮内部数据类型的对象⽽⾔，光⽤maloc/free⽆法满⾜动态对象的要求。
对象在创建的同时要⾃动执⾏构造函数，对象在消亡之前要⾃动执⾏析构函数。
由于malloc/free是库函数⽽不是运算符，不在编译器控制权限之内，不能够把执⾏构造函数和析构函数的任务强加于malloc/free。
因此C++语⾔需要⼀个能完成动态内存分配和初始化⼯作的运算符new，以及⼀个能完成清理与释放内存⼯作的运算符delete。
注意new/delete不是库函数。
2.delete与 delete []区别delete只会调⽤⼀次析构函数，⽽delete[]会调⽤每⼀个成员的析构函数。
在More Effective C++中有更为详细的解释：“当delete操作符⽤于数组时，它为每个数组元素调⽤析构函数，然后调⽤operator delete来释放内存。
”delete与new配套，delete []与new []配套MemTest *mTest1=new MemTest[10];MemTest *mTest2=new MemTest;Int *pInt1=new int [10];Int *pInt2=new int;delete[]pInt1; //-1-delete[]pInt2; //-2-delete[]mTest1;//-3-delete[]mTest2;//-4-在-4-处报错。
这就说明：对于内建简单数据类型，delete和delete[]功能是相同的。
对于⾃定义的复杂数据类型，delete和delete[]不能互⽤。
delete[]删除⼀个数组，delete删除⼀个指针。
用函数引用一整格表-概述说明以及解释
用函数引用一整格表-概述说明以及解释1.引言1.1 概述函数引用是一种重要的编程概念，它可以使我们更加高效地处理大量数据。
当我们需要操作一整格表的数据时，函数引用提供了一种灵活且简洁的方法。
通过函数引用，我们可以直接使用函数来处理整个表格，而不需要逐个遍历每一个元素。
本文将介绍函数引用一整格表的方法以及其优势。
在正文部分，我们将详细讲解函数引用的概念和作用，以及如何使用函数引用一整格表。
结论部分将总结函数引用一整格表的优势，并对其未来的发展进行展望。
通过函数引用一整格表，我们可以避免重复的代码和繁琐的循环操作。
通过定义一个函数，我们可以对整个表格进行一次性的操作，使得代码更加简洁清晰。
此外，函数引用还可以提高代码的复用性和可维护性，当我们需要修改数据处理的逻辑时，只需要修改一个函数即可，而不需要修改所有遍历的代码。
使用函数引用一整格表的方法非常简单。
首先，我们需要定义一个函数，该函数接受一个表格作为参数，并对其进行相应的操作。
然后，我们可以使用该函数来引用整个表格，从而实现对整个表格的操作。
在未来，函数引用一整格表有着广阔的应用前景。
随着数据量的不断增大，对于大规模数据的处理将变得更加重要。
函数引用可以帮助我们更加高效地处理大规模数据，提高数据处理的速度和效率。
此外，函数引用的使用还可以方便数据分析和机器学习等领域的工作，使得数据处理更加方便灵活。
综上所述，函数引用一整格表是一种灵活且高效的数据处理方法。
通过函数引用，我们可以简化代码，提高数据处理的效率，并且具备良好的可维护性和复用性。
未来，函数引用一整格表将在数据处理和分析的领域发挥着更加重要的作用。
1.2文章结构1.2 文章结构文章将按照以下结构进行展开：1. 引言- 1.1 概述- 1.2 文章结构- 1.3 目的2. 正文- 2.1 函数引用的概念和作用- 2.2 使用函数引用一整格表的方法3. 结论- 3.1 函数引用一整格表的优势- 3.2 对函数引用一整格表的展望在引言部分，我们将首先对整篇文章进行一个简要概述，带领读者了解文章的主要内容和目的。
引用作为函数返回值的一点思考
引⽤作为函数返回值的⼀点思考本篇⽂章的关注点是引⽤作为函数返回值，⽹上类似很多，具体可参考。
这⾥，我想写下⾃⼰的想法。
在C++中，引⽤变量必须要初始化，否则会有编译错误。
这⾥指的初始化，⼀般变量赋值初始化。
如果是通过函数返回值来初始化，那就要好好考虑下。
以获取字体信息场景为例⼦：在启动时，通过读取字体配置⽂件来获得字体信息，保存在m_vLogFont。
外部通过GetFont接⼝函数来获得字体信息，每⼀个Id对于⼀种字体，接⼝函数⼤致实现如下：const LOGFONT& GetFont(int nFontId){if (nFontId < m_vLogFont.size()){return m_vLogFont[nFontId];}}// 外部使⽤const LOGFONT& FontInfo = GetFont(FONT_ID);问题⼀：通过函数返回值来定义的引⽤，如何判断其有效性？按照以往的知识，引⽤变量⼀旦初始化，之后就不能再改变。
通过函数返回值也算是初始化，在这种情况下，如果引⽤⽆效，⽐如传⼊⼀个很⼤的FontId，在编译阶段是⽆法发现错误，只有在运⾏阶段，会报读取访问冲突的错误。
解答：这种情况下，在编译期间是⽆法判断其有效性的，在运⾏时可判断。
问题⼆：如果出现上⾯的情况，如何预防？这⾥有两种解决⽅案，以GetFont为例⼦：1. 在if的else分⽀中，加上ASSERT断⾔，在调试阶段发现问题。
2. 在if的else分⽀中，加上出错处理，即获取不到，则返回默认字体信息。
这两种处理⽅式，在实践中都有应⽤，不同⽅式对应的场景不⼀。
⽐如，第⼆种⽅式的应⽤场景是字体配置信息异常。
如果不这么做，会因⼀处配置信息异常，导致整个软件⽆法运作。
解答：如果产品⼈员有这⽅⾯的需求考虑或者之前有类似情况发⽣，这种处理⽅式就是合理的。
否则，推荐第⼀种⽅式。
⼩结：⼯具类函数的返回值需要仔细考虑异常情况，尽量做到异常情况对外部暴露，由外部去处理。
C++引用的作用和用法
C++ 引用的作用和用法引用的好处之一就是在函数调用时在内存中不会生成副本引用总结（1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。
（2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。
（3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。
程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。
（4）使用引用的时机。
流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。
引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。
引用的声明方法：类型标识符&引用名=目标变量名；【例1】：int a; int &ra=a; //定义引用ra,它是变量a的引用，即别名（1）&在此不是求地址运算，而是起标识作用。
（2）类型标识符是指目标变量的类型。
（3）声明引用时，必须同时对其进行初始化。
（4）引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。
ra=1; 等价于a=1;（5）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。
故：对引用求地址，就是对目标变量求地址。
&ra与&a相等。
（6）不能建立数组的引用。
因为数组是一个由若干个元素所成的集合，所以无法建立一个数组的别名。
（7）不能建立引用的引用，不能建立指向引用的指针。
因为引用不是一种数据类型！！所以没有引用的引用，没有引用的指针。
例如：int n；int &&r=n；//错误，编译系统把"int &"看成一体，把"&r"看成一体，即建立了引用的引用，引用的对象应当是某种数据类型的变量int &*p=n;//错误，编译系统把"int &"看成一体，把" *p "看成一体，即建立了指向引用的指针，指针只能指向某种数据类型的变量（8）值得一提的是，可以建立指针的引用例如：int *p;int *&q=p;//正确，编译系统把" int * "看成一体，把"&q"看成一体，即建立指针p 的引用，亦即给指针p起别名q。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
将＂引用＂作为函数返回值类型的格式、好
处和需要遵守的规则
格式：类型标识符&函数名（形参列表及类型说明）{ //函数体}
好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。
因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!
注意事项：
（1）不能返回局部变量的引用。
这条可以参照Effective C++[1]的Item 31。
主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了”无所指”的引用，程序会进入未知状态。
（2）不能返回函数内部new分配的内存的引用。
这条可以参照Effective C++[1]的Item 31。
虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。
例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，
那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。
（3）可以返回类成员的引用，但最好是const。
这条原则可以参照Effective C++[1]的Item 30。
主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。
如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。
（4）流操作符重载返回值申明为“引用”的作用：
流操作符>，这两个操作符常常希望被连续使用，例如：cout
int &put(int n);
int vals[10];
int error=-1;
void main()
{
put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10; put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20; cout=0 && n<=9 ) return vals[n];
else { cout<<”subscript error”; return error; }
}
（5）在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。
它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。
主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。
根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。
静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。
所以可选的只剩下返回一个对象了。