Bootstrap

C++：超越C语言的独特魅力

文章目录

1 函数重载

函数重载有点像“一词多义”，我们汉语的博大精深就经常会出现一词多义的现象，就如同一个笑话一样：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”

1.1 概念

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

C语言是不支持同名函数的，这就是C语言的一个“坑”。比如我们想要实现整数的相加与浮点数的相加：

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;
}

当我们在C语言中调用此函数时就会报错，但是在C++中就不会。在C++中函数重载支持的条件是：函数名相同，参数不同。而函数名相同，参数不同的情况有三种：类型不同、个数不同以及顺序不同。如下，举三个不同例子：

#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 f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << 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);
f();
f(10);
f(10, 'a');
f('a', 10);
return 0;
}

这串代码很好诠释了三种不同，让我们更容易理解。
注意：如果两个函数构成重载，不传参数时使用函数参数的缺省参数就会存在二义性！！！

#include<iostream>
using namespace std;
void f()
{
    cout << "f()" << endl;
}
void f(int a = 0)
{
    cout << "f(int a)" << endl;
}
int main()
{
    f();
    return 0;
}

上述代码就是一个二义性代码，当函数不传参时两个函数都可以调用，这时就非常危险。所以我们要避免这种情况的发生！函数重载不同点全部在函数参数的地方，却在返回值处没有做过多工作，这是为什么呢？我们使用反证法假设返回值不同，但是函数调用却不知道调用谁，所以只能是参数不同才可以区分。

1.2 函数重载的原理

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

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

img

img

  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+函数长度+函数名+类型首字母】。

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

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

img

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

Windows下名字修饰规则 ：

img

对比Linux会发现，windows下vs编译器对函数名字修饰规则相对复杂难懂，但道理都是类似的，我们就不做细致的研究了。

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

所以C语言不支持函数重载，C++支持函数重载！

2 引用

2.1 概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如：水浒传中的林冲，被称为“豹子头”。

类型& 引用变量名(对象名) = 引用实体；

void TestRef()
{
  int a = 10;
  int& ra = a;//<====定义引用类型
  printf("%p\n", &a);
  printf("%p\n", &ra);
}

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

2.2 引用特性

引用在定义时必须初始化：一个变量可以有多个引用；引用一旦引用一个实体，再不能引用其他实体。

void TestRef()
{
 int a = 10;
 // int& ra;  // 该条语句编译时会出错
 int& ra = a;
 int& rra = a;
 printf("%p %p %p\n", &a, &ra, &rra); 
}

别名与原变量的地址相同，所以a创建了变量，b是a的别名，所以b++就是a++的结果，这里也可以给别名取别名!!!

 
int main()
{
	int a = 0;
	int& b = a;
	a++;
	b++;
	cout << a << endl << b << endl;
	return 0;
}

当我们创建一个函数时，参数是指针时，我们也可以用引用进行表示。

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

所以在无哨兵位链表时，我们可以用引用代替二级指针!

引用与指针用法非常相似，但是引用能完全替代指针吗？我们来看一段代码：

int main()
{
	int a = 0;
	int& c = a;
	int b = 1;
	//c变成b的别名还是给c赋值呢？
	c = b;
	printf("%d %d %d \n", a, b, c);
	return 0;
}

上述代码是c变成b的别名还是给c进行赋值呢？如果c变成b的别名就是改变指向的？如果b给c进行赋值就不能改变指向。很明显不能改变指向。只是单纯的赋值，所以引用与指针的区别出现了，引用无法替代指针。

2.3 常引用

什么是常引用，就是对不可修改的常量做引用，这样做与#define宏定义有点类似，但是底层逻辑是不相同的，**宏定义是在预处理阶段进行替换，所以常引用可以进行调试出理，但是宏定义就不行。**那怎样进行常引用定义呢？

void TestConstRef()
{
  const int a = 10;
  //int& ra = a;  // 该语句编译时会出错，a为常量
  const int& ra = a;
  // int& b = 10; // 该语句编译时会出错，b为常量
  const int& b = 10;
  double d = 12.34;
  //int& rd = d; // 该语句编译时会出错，类型不同
  const int& rd = d;
}

以上是常引用定义的错误点，就是因为使用了常引用将本没有权限的内容变得有权限，导致不合理，所以出现错误。

总结：常引用可以将定义的内容权限缩小，但是不能进行放大。

2.4 使用场景

2.4.1 做参数

void Swap(int& left, int& right)
{
 int temp = left;
 left = right;
 right = temp;
}

做参数在上文已经提到，这里就不做过多的解释。

2.4.2 做返回值

int& Count()
{
 static int n = 0;
 n++;
 // ...
 return n;
}

我们可以将返回值设置为int&，但是我们没有进行取别名的操作，为什么还可以进行返回呢？因为计算机可以帮我们自动取一个别名(我们不知道)然后进行函数返回值的返回。**我们一般int的类型的返回值是将返回内容进行拷贝一份进行返回，因为在函数栈帧调用后函数内存就会被销毁！**那就有人会闻，函数栈帧都被销毁了，取的别名传的内容就是一个错误的内容吗？

这就会引出我们下面的问题，下面代码会输出什么结果？

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;
}

img

那为什么是7，不应该是3吗？img

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

这里无论是3还是7都是不严谨的，有的程序还会返回错误值，这都取决于内存是否环给系统。但是我们这里给ret赋值一次，但是却出现了第二次调用的值，就是因为ret是计算机给出c的别名，地址都是相同的，所以只要调用一次函数就会更新ret中的值！上面函数栈帧图非常清楚，我们可以理解一下！！！

所以用引用作为返回值去返回临时变量是非常危险的，所以我们应该返回static静态变量！

2.5 传值、传引用效率比较

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

#include <time.h>
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

当我们进行大规模传参时，传值需要进行拷贝，而传引用却不需要，所以根据上述代码我们可以看到传引用比传值的效率高很多。

值和引用的作为返回值类型的性能比较：

#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;
}

返回值也是如此，传值时需要将返回值进行拷贝而传引用不用，所以传引用相率高。

总结：通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

2.6 引用和指针的区别

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

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

上述代码所打印出的地址相同，所以从语法层面来看引用是没有空间开辟的。 在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}

上述代码我们转成汇编语言进行观看：

img

转成汇编语言后，发现引用与指针的逻辑是相同的。

引用和指针的不同点:

  1. 引用概念上定义一个变量的别名，指针存储一个变量地址；
  2. 引用在定义时必须初始化，指针没有要求；
  3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体；
  4. 没有NULL引用，但有NULL指针；
  5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)；
  6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；
  7. 有多级指针，但是没有多级引用；
  8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理；
  9. 引用比指针使用起来相对更安全。

3 内联函数

3.1 概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。img

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

查看方式：

  1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add
  2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)

img

img

3.2 特性

  1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

  2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为《C++prime》第五版关于inline的建议：img

  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到了。

所以inline的特性与register非常相似，是一种“请求”，程序会根据实际进行选择优化！！！

文章已获作者授权转载，版权归原作者所有，如有侵权，与本账号无关，可联系删除。 原文作者:W.Y

原文链接：https://blog.csdn.net/m0_74755811/article/details/133874519

在这里插入图片描述

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
pytest的安装和介绍和 Exit Code 含义
（12）RCC与时钟树编程—基于铁头山羊的STM32标准库教程
linux block层相关
map与set的介绍使用
TrueNAS搭建网络储存系统
云闪付怎么设置不跳华为支付_【教程】华为Pay用闪付券撸京东E卡！
(CVPR-2024)SwiftBrush：具有变分分数蒸馏的单步文本到图像扩散模型
Java运算符
Stable Diffusion教程|练丹师是如何炼丹的Lora模型训练
基于SpringBoot的酒店订房系统-82159（免费领源码+数据库）可做计算机毕业设计JAVA、PHP、爬虫、APP、小程序、C#、C++、python、数据可视化、大数据、全套文案
;