c++函数的缺省与哑元、函数引用、函数重载、内联函数、动态内存管理

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、当我们调用一个重载函数时，编译器会根据我们提供的参数类型、个数和顺序来确定应该调用哪个具体的函数。