C++入门:函数缺省参数与函数重载

目录

1.函数缺省参数

[1.1 缺省参数概念](#1.1 缺省参数概念)

[1.2 缺省参数分类](#1.2 缺省参数分类)

2.函数重载

[2.1 函数重载概念](#2.1 函数重载概念)

[2.2 C++支持函数重载的原理](#2.2 C++支持函数重载的原理)


1.函数缺省参数

1.1 缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时,如果没有指定实

参则采用该形参的缺省值,否则使用指定的实参,有点备胎的意思。

cpp 复制代码
void Func(int a = 0)
{
    cout << a << endl;
}
int main()
{
    Func(); // 没有传参时,使用参数的默认值 ,打印0
    Func(10); // 传参时,使用指定的实参 , 打印10
    return 0;
}

1.2 缺省参数分类

1.全缺省参数

cpp 复制代码
//全缺省
void Func(int a = 10, int b = 20,int c =30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}

int main()
{
	Func();
	
	//显示传参,必须从左往右连续显示传参,
	Func(1);
	Func(1, 2);
	Func(1, 2, 3); 
	return 0;
}

2.半缺省参数

cpp 复制代码
半缺省,缺省部分,必须从右往左,给缺省值
void Func(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
} 

int main()
{
	//没有缺省的必须传
	Func(1);
	Func(1, 2);
	Func(1, 2, 3);
}

注意:

  1. 半缺省参数必须从右往左依次来给出,不能间隔着给

  2. 缺省参数不能在函数声明和定义中同时出现,C++规定声明给,定义不给 。错误示例:

    cpp 复制代码
    //a.h
    void Func(int a = 10);
    // a.cpp
    void Func(int a = 20)
    {}
    // 注意:如果声明与定义位置同时出现,恰巧两个位置提供的值不同,
    //那编译器就无法确定到底该用那个缺省值
  3. 缺省值必须是常量或者全局变量

  4. C语言不支持(编译器不支持)

函数缺省参数的应用:

在使用某种数据结构例如栈在申请空间时,如果我们知道需要使用多少空间时,可以直接把空间大小传入,不用多次realloc调整空间,示例:

cpp 复制代码
------------------------Stack.h------------
#include<iostream.h>
#include<stdlib.h>
namespace s
{
	typedef struct Stack
	{
		int* a;
		int top;
		int capacity;
	}Stack;

	//不允许声明和定义同时给缺省参数     C++规定 声明给 定义不给
	void StackInit(Stack* ps, int n = 4);//缺省值为4

	void StackPush(Stack* ps, int x);
}
-----------------------Stack.cpp-------------
#include"Stack.h"

void s::StackInit(Stack* ps, int n)
{
	ps->a = (int*)malloc(sizeof(int) * n);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->top = 0;
	ps->capacity = n;
}
void s::StackPush(Stack* ps, int x)
{
	if (ps->top == ps->capacity)
	{
		int* ptr = (int*)realloc(ps->a, sizeof(int) * ps->capacity * 2);
		if (ptr == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->capacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
----------------------test.cpp--------------
#include"Stack.h"
using namespace s;
int main()
{
	//知道要插入多少个
	Stack st1;
	StackInit(&st1, 10);
	for (int i = 0; i < 10; i++)
	{
		StackPush(&st1,i);
	}
	Stack st2;
	StackInit(&st2, 100);
	for (int i = 0; i < 100; i++)
	{
		StackPush(&st2,i);
	}
	//不知道要插入多少个时
	Stack st3;
	StackInit(&st3);

	return 0;
}

在头文件中定义函数时:

在头文件中定义函数,当这个头文件被多个.cpp文件包含时,会发生链接错误,重复定义,可以在函数前加static改变链接属性,由外部链接改为内部链接,只能在当前文件使用。

2.函数重载

自然语言中,一个词可以有多重含义,人们可以通过上下文来判断该词真实的含义,即该词被重载了。

比如:以前有一个笑话,国有两个体育项目大家根本不用看,也不用担心。一个是乒乓球,一个是男足。前者是"谁也赢不了! ",后者是"谁也赢不了!"

2.1 函数重载概念

函数重载:是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数或类型或类型顺序)不同,常用来处理实现功能类似数据类型不同的问题。

cpp 复制代码
#include<iostream>
using namespace std;

//1.参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}

//2.参数个数不同
void func()
{
	cout << "func()" << endl;
}

void func(int x)
{
	cout << "func = " << x << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

int main()
{
    //函数重载,可以自动匹配 , 如何实现自动匹配,函数名修饰规则,下面会讲
    Add(10, 20);
    Add(10.1, 20.2);
    //cout自动匹配类型本质也是函数重载
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

注意:

  1. 顺序不同不是指的形参的名字顺序不同,而是参数类型顺序不同

    cpp 复制代码
    //func1构不成函数重载,会重定义
    void func1(int x, double y)
    {
    	//...
    }
    void func1(int y, double x)
    	//...
    }
    //func2构成函数重载
    void func2(int x, double y)
    {
    	//...
    }
    void func2(double x, int y)
    {
    	//...
    }
  2. 只有返回值不同构不成函数重载

不同作用域构不成函数重载,把命名空间展开也可以构成

cpp 复制代码
//不同作用域构不成函数重载,但是展开作用域后构成
namespace s1
{
	void func(int x)
	{
		cout << "func = " << x << endl;
	}
}
namespace s2
{
	void func(double x)
	{
		cout << "func = " << x << endl;
	}
}
using namespace s1;
using namespace s2;

命名空间名称相同合并,也构成函数重载

cpp 复制代码
//命名空间相同合并,构成函数重载
namespace s1
{
	void func(int x)
	{
		cout << "func = " << x << endl;
	}
}
namespace s1
{
	void func(double x)
	{
		cout << "func = " << x << endl;
	}
}

函数重载遇上函数缺省参数

cpp 复制代码
//构成重载 参数个数不同
//调用时发生问题,调用存在歧义
void func(int x)
{
	cout << "void func(int x)" << endl;
}
void func(int x,int b = 1)
{
	cout << "void func(int x,int b = 1) " << endl;
}

int main()
{
	func(1, 2);//可以调用
	//调用时发生问题,调用存在歧义,与重载没有关系
	//func(1);
	return 0;
}

调用时发生问题,调用存在歧义,但会发生重载。

2.2 C++支持函数重载的原理

为什么C++支持函数重载,而C语言不支持函数重载呢?

在C/C++中,一个程序要运行起来,需要经历翻译:编译、链接。而编译又有三个阶段:预处理,编译,汇编。

程序翻译阶段:

程序编译阶段:

  1. 实际项目通常是由多个头文件和多个源文件构成,编译是分隔开的。【当前a.cpp中调用了b.cpp中定义的Add函数时】,编译后链接前,a.o的目标文件中没有Add的函数地址,因为Add是在b.cpp中定义的,所以Add的地址在b.o中。那么怎么办呢?

  2. 所以链接阶段 就是专门处理这种问题,链接器看到a.o调用Add,但是没有Add的地址,就会到b.o的符号表中找Add的地址,然后链接到一起,即合并符号表,符号表上有每个函数名以及对应的地址

  3. 那么链接时,面对Add函数,链接接器会使用哪个名字去找呢?在C++中,编译器都有自己的函数名修饰规则,让重载的函数区别开来,是用修饰后的名字放到符号表而C语言是直接使用函数名做符号表的名字,没有进行修饰,所以重载会冲突

  4. 由于Windows下vs的修饰规则过于复杂,而Linux下g++的修饰规则简单易懂,下面我们使用了g++演示这个修饰后的名字。

  5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母

示例:

cpp 复制代码
void func(int x, double y)
{
	cout << "void func(int x, double y)" << endl;
}
void func(double x, int y)
{
	cout << "void func(double x, int y)" << endl;
}

int main()
{
	func(1, 1.1);
	func(1.1, 1);
	return 0;
}

调用函数转到汇编:

可以发现是使用了 call 指令跳转到 func 函数第一行的地址。函数的地址本质可以认为是函数第一句指令的地址,只有声明没有定义会找不到,生不成地址。下面是只有声明没有定义的报错:

可以发现第一个函数名已经被修饰为:(?func@@YAXHN@Z),int被修饰成H,double被修饰成N。这里重载参数顺序不同,所以被修饰后的两个函数名也不同

我们来看一Linux下g++的修饰规则:

一个是**<_Z4funcid>** 一个是**<_Z4funcdi>** ,函数名修饰规则是:**【_Z + 函数名字符个数 + 函数名 + 类型首字母】**int 是 i ,double 是 d,指针类型前面加p,int * 是 pi,可以发现:

函数名修饰规则本质是把参数类型带进名字了,类型不同,个数不同,顺序不同,修饰的名称就不同。所以返回值不同,不能构成函数重载,因为函数名修饰规则里没有返回值。

**结论:**在linux下,采用g++编译完成后,函数名字的修饰发生改变,编译器将函数参数类型信息添加到修改后的名字中。

这里就有一个问题了,如果把返回值带入函数名修饰规则,能不能构成重载?

答案是不能,你会发现在调用时,就不知道调用谁,示例:

cpp 复制代码
void func(int x, double y)
{
	//...
}
int func(int x, double y)
{
	//...
    return 1;
}
//不会构成函数重载
int main()
{
	func(1, 1.1);//不知道到底调用哪一个
    func(1, 1.1);
	return 0;
}

结论:

  1. 通过这里就理解了C语言没办法支持重载,因为同名函数没办法区分。而C++是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持了重载。
  2. 如果两个函数函数名和参数是一样的,返回值不同是不构成重载的,因为调用时编译器没办法区分

本篇结束。

相关推荐
明月看潮生12 分钟前
青少年编程与数学 02-003 Go语言网络编程 15课题、Go语言URL编程
开发语言·网络·青少年编程·golang·编程与数学
南宫理的日知录23 分钟前
99、Python并发编程:多线程的问题、临界资源以及同步机制
开发语言·python·学习·编程学习
逊嘘40 分钟前
【Java语言】抽象类与接口
java·开发语言·jvm
van叶~42 分钟前
算法妙妙屋-------1.递归的深邃回响:二叉树的奇妙剪枝
c++·算法
Half-up42 分钟前
C语言心型代码解析
c语言·开发语言
knighthood20011 小时前
解决:ros进行gazebo仿真,rviz没有显示传感器数据
c++·ubuntu·ros
Source.Liu1 小时前
【用Rust写CAD】第二章 第四节 函数
开发语言·rust
monkey_meng1 小时前
【Rust中的迭代器】
开发语言·后端·rust
余衫马1 小时前
Rust-Trait 特征编程
开发语言·后端·rust
monkey_meng1 小时前
【Rust中多线程同步机制】
开发语言·redis·后端·rust