C++入门知识（中）

冧轩在努力

已于 2023-05-14 12:21:13 修改

阅读量196

点赞数 15

分类专栏： C++学习笔记文章标签： c++ 开发语言

于 2023-05-03 20:00:28 首次发布

本文链接：https://blog.csdn.net/m0_72532428/article/details/130459479

版权

C++学习笔记专栏收录该内容

20 篇文章 1 订阅

订阅专栏

2.3C++支持函数重载的原理----名字修饰

一、缺省参数

1.1缺省参数的概念

缺省参数：声明或定义函数时为函数的参数指定一个缺省值，在调用函数时如果没有指定实参，那么将会采用该函数的缺省值，否则使用指定的实参。

namespace lx 
{
	void print(int a=1)
	{
		cout << a << endl;
	}
}
using namespace lx;

int main()
{
	print();
	print(20);
	return 0;
}

1.2缺省参数的分类

缺省参数分为全缺省参数和半缺省参数

①全缺省参数

全部的形参都给指定的缺省值

namespace lx 
{
	void print(int a=1,int b=2,int c=3)
	{
		cout << a << ',' << b << ',' << c << endl;
	}
}
using namespace lx;
int main()
{
	print();
	print(20);
	print(20, 21);
	print(20, 21, 22);
	return 0;
}

如果不传参数的话，那么就会使用缺省值，如上面的结果

②半缺省参数

部分形参给指定的缺省值

namespace lx 
{
	void print(int a,int b=2,int c=3)
	{
		cout << a << ',' << b << ',' << c << endl;
	}
}
using namespace lx;
int main()
{
	print(20);
	print(20, 21);
	print(20, 21, 22);
	return 0;
}

这里需要注意的是，缺省值只能从右往左给，否则将会报错，给的时候不能跳着给，传参的时候也不能跳着传，否则会报错，不符合语法，就像下图的传参方式是不合法的

注：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

5.缺省参数必须是常量或全局变量

二、函数重载

2.1函数重载的概念

函数重载：C++中允许在同一作用域中存在多个功能类似的同名函数，这些同名函数的形参列（参数类型、顺序、个数）不同，多数用来处理实现功能类似但参数类型不同的问题

2.2形参列表不同举例

①参数类型不同

void print(int a, int b = 2, int c = 3)
	{
		cout << a << ',' << b << ',' << c << endl;
	}

void print(double a, int  b = 2, int c = 3)
	{
		cout << a << ',' << b << ',' << c << endl;
	}

void print(double a, double b = 2, double c = 3)
	{
		cout << a << ',' << b << ',' << c << endl;
	}

②参数类型顺序不同

void print(double a, int  b = 2, char c = 'A')
	{
		cout << a << ',' << b << ',' << c << endl;
	}

void print(int a, double  b = 2, char c = 'A')
	{
		cout << a << ',' << b << ',' << c << endl;
	}

void print(int a, char b = 'A', double c = 2)
	{
		cout << a << ',' << b << ',' << c << endl;
	}

③参数个数不同

void print(int a)
	{
		cout << a << endl;
	}

void print(int a, char c = 'A')
	{
		cout << a  << ',' << c << endl;
	}

void print(double a, int  b = 2, char c = 'A')
	{
		cout << a << ',' << b << ',' << c << endl;
	}

2.3C++支持函数重载的原理----名字修饰

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

在C/C++中运行起来需要经历：预处理、编译、汇编、链接四个阶段

1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们
可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标
文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么
怎么办呢？
2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就
会到b.o的符号表中找Add的地址，然后链接到一起。
3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的
函数名修饰规则。
4. 由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使
用了g++演示了这个修饰后的名字。
5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度
+函数名+类型首字母】

int Add(int a,int b)
{
		return a + b;
}
void func(int a, double b,int* p)
{
	
}
int main()
{
	Add(1, 2);
	func(1, 2, 0);
	return 0;
}

采用C语言编译器编译后结果

结论：在Linux下，采用gcc编译完成后，函数名字的修饰没有发生改变

采用C++编译器编译后结果为：

结论：在Linux下，采用g++编译器编译以后，函数名字的修饰发生了改变，编译器将函数参数类型信息添加到了修改后的名字中

Windows下的函数名修饰规则较为复杂，但是和Linux函数名修饰都有相同的作用，这就不过多述说了。

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

三、引用

3.1引用的概念

引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量使用同一块内存空间

比如：罗翔老师，在网络上人们都称他为“法外狂徒张三”

引用格式：类型 & 引用变量名（或类名）= 引用实体

int main()
{
	int a = 0;
	int& a1 = a;//定义引用类型
	cout << a << endl;
	cout << a1 << endl;
	printf("%p\n", &a);
	printf("%p\n", &a1);
	return 0;
}

可以发现它们使用同一块空间，值相同

注意：引用类型必须和引用实体是同种类型的

3.2引用特性

①引用在定义时必须初始化

int main()
{
	int a = 0;
	//int& a1;   //这条语句会报错，不符合语法
	int& a1 = a;
	int b = 10;
	a1 = b;  //表示把b的值赋给a1
	//a1值的改变也会改变a的值
	cout << "a1的值:" << a1 <<' ' << "a的值:" << a << endl;
	return 0;
}

②一个变量可以有多个引用

int main()
{
	int a = 0;
	int& a1 = a;
	int& b = a;
	int& c = a;
	printf("%p %p %p %p", &a, &a1, &b, &c);
	return 0;
}

③引用一旦引用一个实体，将不能再引用其他实体

3.3常引用

int main()
{
	const int a = 10;
	//int& a1 = a;  //该语句会报错，a为常量，a的权限被放大了
	const int& a1 = a;
	
	//int& b = 10; //该语句会报错
	const int& b = 10;
	double c = 10.0;   //只是把值赋给c,不会报错
	//int& c1 = c;     //该语句会报错
	double& c1 = c;
	const int& c2 = c; //隐式类型转换出了一个临时变量，临时变量具有常性
	return 0;
}

注：引用时，变量的权限可以被缩小但不能被放大，当引用类型不同时，会发生隐式类型转换，而转换出的临时变量具有常性，所以需要用const来修饰

3.4使用场景

①做参数

此时传的参数是传引用不会开辟新的空间，引用改变也会改变被引用实体

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

②做返回值

int& count()
{
	static int n;
	++n;
   return n;
}

下面的代码会返回什么呢？

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

可以发现，此时返回的是一个随机值，这显然不是我们需要的值。

看到这肯定会有疑惑，为什么不是我们需要的值呢？

原因：变量c是在栈上定义的，当函数调用完后，函数栈帧会销毁，变量c自然也被销毁了，使用权限还给了系统。而②中的n没被销毁是因为n是在全局变量区定义的，n的生命周期不随着栈帧的销毁而结束，所以②中返回的不是随机值

注意：如果函数返回时，出了函数作用域，返回对象还没被销毁（还没还给系统），则可以使用引用返回，否则只能使用传值返回。

3.5传值返回和传引用返回的性能比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直
接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效
率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{ 
	TestReturnByRefOrValue();
	return 0;
}

可以发现，传值返回的效率比较低，传引用返回的效率很高。它们的返回效率相差甚大。

3.6引用和指针的区别

①在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
	int a = 10;
	int& a1 = a;
	cout << &a1 << " " << &a << endl;
	return 0;
}

②在底层实现上实际是有空间的，因为引用是按照指针方式来实现的

int main()
{
	int a = 10;

	int& a1 = a;
	a1 = 20;

	int* pa = &a;
	*pa = 20;

	return 0;
}

通过下面的汇编代码可以发现它们原理是一样的

引用和指针的不同点

1.引用概念上是给实体去一个别名，指针存储该实体的地址

2.引用在定义时必须初始化，指针没有要求

3.引用在初始化时引用一个实体后就不能再引用其他实体，而指针可以随时指向任何相同类型的实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

今天的分享就到这里了，感谢支持，有不对的地方请帮忙指出来，谢谢咯。