c++函数
1. 函数缺省参数
在c++中,函数的参数形参列表中的形参可以是有默认值的,有默认值的参数即为默认参数。
在函数调用时,有默认值参数可以缺省。
语法:返回值类型 函数名 (参数 = 默认值){函数体}
#include <iostream>
using namespace std;
int add(int x, int y, int z=30)
{
return x + y + z;
}
int main(void)
{
cout << add(2, 3, 5) << endl;
cout << add(3, 5) << endl;
return 0;
}
注意事项:
- 靠右原则:如果某个位置参数有默认值,那么从这个位置往后,从左向右,必须都要有默认值。
int add(int x, int y=20, int z)//error
- 函数声明和函数实现(即函数定义),只允许其中一个有默认值,即如果函数声明有默认值,则函数实现的时候就不能有缺省参数。(函数实现和函数声明只有函数声明才能有默认值)
#include <iostream>
using namespace std;
int add(int x, int y, int z=30);
int main(void)
{
cout << add(2, 3, 5) << endl;
cout << add(3, 5) << endl;
return 0;
}
int add(int x, int y, int z)
{
return x + y + z;
}
2.哑元
只有类型而没有变量名的参数称为“哑元”。
int func(int a, int ){
...
}
需要使用哑元的场景:
- 兼容旧代码,保证函数的向下兼容性
void func(int i,int j){…}==升级==>void func(int i){…}
void func(int i,int j){…}==升级==>void func(int i, int/*哑元*/){…}
- 操作符重载中,区分前后++/–
3.引用参数
-
可以将引用用于函数的参数,这时形参就是实参的别名
-
引用型函数参数作用
- 在函数中修改实参的值
#include <iostream>
using namespace std;
void swap(int & ,int&);
int main()
{
int i =3,j = 5;
swap(i,j);
cout<<"i="<<i<<endl<<"j="<<j<<endl;
getchar();
return 0;
}
void swap(int &a,int &b)
{
int temp;
temp = a;
a =b;
b= temp;
}
- 避免实参到形参数值复制的开销,提高传参效率
#include <iostream>
using namespace std;
struct Teacher{
char name[100];
int age;
};
void print( Teacher& t){
cout << t.name << ',' << t.age/*++*/ << endl;
}
int main(void)
{
const Teacher t = {"张飞",40};
print(t);
print(t);
print(t);
return 0;
}
- 引用型函数参数可能意外修改实参,如果不希望通过引用修改实参本身,可以将其声明为常引用,在提高传参效率的同时还可以接收常量型实参
使用const 使之成为常引用,避免函数实现的时候改变实参的值(下面a++位置报错)
#include <iostream>
using namespace std;
int add(const int &a, const int &b)
{
a++;
//error: increment of read-only reference ‘a’
return a + b;
}
int main(void)
{
int a = 12;
int b = 34;
cout << add(a, b) << endl;
cout << add(1,2) << endl;
return 0;
}
使用const后,可以传右值了,如下(当去掉const
时add(1,2)
会报错)
int add( int &a, int &b)
{
return a + b;
}
int main(void)
{
int a = 12;
int b = 34;
cout << add(a, b) << endl;
************************
cout << add(1,2) << endl;
//error: cannot bind non-const lvalue reference of type ‘int&’ to an rvalue of type ‘int’ 意思是不能传右值。
*************************
return 0;
}
4.返回引用
-
可以将函数的返回类型声明为引用型,这时函数的返回结果就是return后面数据的别名,避免了函数返回值的开销
-
函数中返回引用,一定要保证在函数返回以后,该引用的目标依然有效
-
可以返回全局变量、静态变量和成员变量的引用
-
可以返回引用型参数的本身
-
可以返回调用对象自身的引用
-
可以返回堆中动态创建对象的引用
-
不能返回局部变量的引用//非常危险
-
#include <iostream>
using namespace std;
int& add(const int &a, const int &b)
{
int tmp = 0;
tmp = a + b;
return tmp; //风险 函数结束对应内存空间回收
}
int main(void){
int x = 100;
int y = 200;
int &t = add(x,y);
t++;//通过别名操作 已经被系统回收的内存
cout << t <<endl;
return 0;
}
需要注意返回的别名对应的内存,当子函数调用后,对应内存还在不在,可以使用全局变量或者加上static 增加生命周期。
5.函数重载
5.1基本使用
同一作用域,函数名相同,但是参数表有所区分(类型、个数、顺序),将构成重载关系————>>>>就是函数名可以相同,只要形参的<<<<<类型、个数、顺序>>>>>其中的任意一个或多个不同就可以构成重载关系。
#include <iostream>
using namespace std;
void func(int a, char *p){
}
void func(char *p, int a){//形参的顺序不同的函数重载
}
void swap(int *a, int *b){//形参的类型不同的函数重载
int tmp = *a;
*a = *b;
*b = tmp;
}
void swap(char *a, char *b){
char tmp = *a;
*a = *b;
*b = tmp;
}
void swap(bool *a, bool *b){
bool tmp = *a;
*a = *b;
*b = tmp;
}
int main(){
int x = 10;
int y = 20;
swap(&x, &y);
cout << x <<" " << y << endl;
char a = 'a';
char b = 'b';
swap(&a, &b);
cout << a << " " << b << endl;
bool f1 = true;
bool f2 = false;
swap(&f1, &f2);
cout << f1 << " " << f2 << endl;
return 0;
}
5.2 重载的实现
编译器将形参变量的类型作为最终函数名的一部分。
mn a.out
注意
形参变量名不同 不构成重载的要素
函数返回类型不同 不构成重载的要素
5.3 函数匹配的优先级
当前g++编译器匹配的一般规则:
1)完全匹配 //最高
2)常量转换 //较好
3)升级转换 //一般
4)降级转换 //较差
5)省略号匹配 //最差
#include <iostream>
using namespace std;
void bar(int i){
cout <<"bar(int)" << endl;
}
void bar(const char c){
cout << "bar(const char)" <<endl;
}
void foo(char c){
cout << "foo(char)" << endl;
}
void foo(int i){
cout << "foo(int)" << endl;
}
void hum(int i, ...){
cout <<"hum(int, ...)" << endl;
}
void hum(int i, int j){
cout << "hum(int, int)" << endl;
}
int main(){
int m = 100;
bar(m);//完全匹配
char c = 'A';
bar(c); //常量转换 char -----> const char
short s = 10;
foo(s); // short ----> int
hum(10, 1.23); // double -----> int 降级转换
return 0;
}
注意二义性问题:
- 默认类型转换带来的二义性
int func(unsigned int x){
return x;
}
double func(double x){
return x;
}
int n = 12;
func(n); // error 全都是升级转换,编译器搞不清 报ambigous
- 缺省参数带来的二义性
void f(int a, int b , int c=100){
}
void f(int a, int b){
}
f(1,2); // ambigous
6.内联函数
在函数声明或定义时,将inline关键字加在函数返回类型前面就是内联函数。
#include <iostream>
using namespace std;
inline int add(int x, int y){ //内联函数
return x+y;
}
int main(void){
int ret = add(3,5); // int ret = 3+5;
return 0;
}
不需要建立函数调用时的运行环境,不需要进行参数传递 , 不需要跳转,效率更高。
注意:
-
inline关键字只是建议编译器做内联优化,编译器不一定做内联
-
内联函数的声明或定义必须在函数调用之前完成
-
一般几行代码适合作为内联函数, 像递归函数 包含循环 switch goto复杂逻辑的函数不适合内联
7. 动态内存管理
在C语言中,如果需要使用堆内存,程序员可以用函数malloc()从堆中分配指定大小存储区域,用完之后必须用free()将之归还系统。如果用完之后没用free()释放,就会造成内存泄漏。
malloc()函数的使用比较麻烦,除了需要计算需求内存的大小之外,还必须对获得的内存区域进行类型转换。为此C++提供了new 和delete两个运算符。
- new的用法
p = new type
p = new type(x)
p = new type[n]
其中p是指针变量,type是数据类型。用法1 只分配内存, 用法2将分配的堆内存初始化为x,用法3分配具有n个元素的数组。分配不成功返回空指针(NULL)。
- delete的用法
delete p;
delete [] p;
其中p是用new分配到的堆空间指针变量。用法1用于释放动态分配的单个内存,用法2用于释放动态分配的数组存储区。
问题
函数重载的构成条件是什么,函数重载是如何实现的?
函数重载是面向对象编程语言中的一种特性,它允许在同一个作用域内定义多个同名函数,只要这些函数的参数列表(参数的类型、个数或顺序)不同即可。这样,编译器就可以根据函数调用时提供的参数类型、个数和顺序来决定调用哪个函数。
构成条件:
1、函数名必须相同:重载函数的名称必须完全一致。
2、参数列表必须不同:这包括参数的类型、个数或顺序不同。只要这三个方面中任意一个方面不同,就可以认为是不同的函数。
3、返回类型可以相同也可以不同:但仅通过返回类型的不同来区分函数重载是不允许的,即如果两个函数仅返回类型不同而参数列表完全相同,则不构成重载。
4、函数的修饰符(如const)和引用也可以作为重载的依据:但这也必须体现在参数列表的不同上。
函数重载的实现
1、当我们编写重载函数时,实际上是在定义多个具有相同名称但参数列表不同的函数。
2、编译器在编译过程中,会根据每个函数的参数列表生成一个唯一的内部名称。
3、在链接阶段,链接器使用这些内部名称来区分不同的函数,并确保函数调用的正确性。
4、当我们调用一个重载函数时,编译器会根据我们提供的参数类型、个数和顺序来确定应该调用哪个具体的函数。