【C++】：函数重载，引用，内联函数，auto关键字，基于范围的for循环，nullptr关键字

2024-04-21 00:12
文章标签 c++ 函数 引用 重载 范围 关键字 循环 auto nullptr 内联

本文主要是介绍【C++】：函数重载，引用，内联函数，auto关键字，基于范围的for循环，nullptr关键字，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

  • 一，函数重载
    • 1.1 函数重载的定义
      • 1.1.1.形参的类型不同
      • 1.1.2参数的个数不同
      • 1.1.3.参数的顺序不同
      • 1.1.4.有一个是缺省参数构成重载。但是调用时存在歧义
      • 1.1.5.返回值不同，不构成重载。因为返回值可接收，可不接受，调用函数产生歧义。
    • 1.2 C++支持函数重载的原理 -- 名字修饰
  • 二，引用
    • 2.1 引用的概念
    • 2.2 引用的使用场景
      • 2.2.1 引用做参数
      • 2.2.2 引用做返回值
    • 2.3 引用特性
    • 2.4 引用的权限问题
      • 2.4.1 举例1
      • 2.4.2 举例2
      • 2.4.3 举例3
      • 2.4.4 总结
    • 2.5 常引用
      • 2.5.1 类型转换时
      • 2.5.2 表达式运算时
    • 2.6 传值、传引用效率比较
    • 2.7 引用和指针的区别
  • 三，内联函数
    • 3.1 内联函数的概念
    • 3.2 inline 关键字
    • 3.3 内联的特性
  • 四，auto关键字(C++11)
    • 4.1 给类型取别名
    • 4.2 可由初始化自动推导类型
    • 4.3 auto不能推导的场景
  • 五，基于范围的for循环
    • 5.1 范围for的语法
    • 5.2 范围for的使用条件
  • 六，nullptr关键字

一，函数重载

在C语言中，同名函数是不能出现在同一作用域的，但是在C++中却可以，但是要满足函数重载的规则。

那什么是函数重载呢？它的规则是什么呢？

1.1 函数重载的定义

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

举几个例子：

1.1.1.形参的类型不同

void Swap(int* pa, int* pb)
{cout << "void Swap(int* pa, int* pb)" << endl;
}void Swap(double* pa, double* pb)
{cout << "void Swap(double* pa, double* pb)" << endl;
}int main()
{int a = 0, b = 1;double c = 1.1, d = 2.2;Swap(&a, &b);Swap(&c, &d);return 0;
}

在这里插入图片描述

1.1.2参数的个数不同

在这里插入图片描述

1.1.3.参数的顺序不同

void f(int a, char b)
{cout << "void f(int a, char b)" << endl;
}void f(char c, int d)
{cout << "void f(char c, int d)" << endl;
}int main()
{int a = 0, b = 1;double c = 1.1, d = 2.2;f(1,'c');f('d',3);return 0;
}

在这里插入图片描述

1.1.4.有一个是缺省参数构成重载。但是调用时存在歧义

void f()
{cout << "void f()" << endl;
}void f(int a = 10)
{cout << "void f(int a = 10)" << endl;
}int main()
{int a = 0, b = 1;double c = 1.1, d = 2.2;f();f(5);return 0;
}

在这里插入图片描述

1.1.5.返回值不同，不构成重载。因为返回值可接收，可不接受，调用函数产生歧义。

int f()
{return 0;
}void f()
{cout << "void f(char c, int d)" << endl;
}int main()
{int a = 0, b = 1;double c = 1.1, d = 2.2;int ret = f();cout << ret << endl;f();return 0;
}

在这里插入图片描述

1.2 C++支持函数重载的原理 – 名字修饰

为什么C++存在重载，C语言不支持？C++为什么支持？

这两个问题深究起来十分复杂。它们与预处理、编译、汇编、链接有极大的关系，这里只是大致解释，只要记住结论即可。

在一般的工程项目中，都会进行多文件操作，那一个函数就一定会声明与定义分离。

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/233f4fee513464e831df277ce671d5e.png

通过上图我们需要知道的两点：

1.函数的地址：转到反汇编时，每个函数都有一堆要执行的指令，函数的地址是第一句指令的地址。
2.函数的地址要依靠函数的定义生成，而不是函数声明。

函数的重载发生在函数链接的时候。
C语言在链接时，直接用函数名去查找，当遇到同名函数时，无法区分，就不支持重载。
C++在链接时，直接用修饰后的函数名去查找，当遇到同名函数时，可以区分，支持重载。

其实不同的编译器有不同的函数名修饰规则。
在Linux的g++编译器下：

C语言不支持重载，直接就是函数名：
在这里插入图片描述

C++支持重载，有函数名的修饰：

在这里插入图片描述

上面的图文看不懂没关系。通过上面的分析。可以得出结论：

  • 在项目工程中，使用多文件操作，函数的定义与声明分离，而在链接的时候，要用函数名去找地址。C语言直接用函数名去查找，当遇到同名函数时，无法区分，而C++有函数名修饰规则，只要参数不同，修饰出来的名字就不一样，可以区分 。并且不同编译器的修饰规则不同。

二，引用

2.1 引用的概念

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

举个例子：

int main()
{int a = 1;//引用：&  b是a的别名int& b = a;//也可以给别名取别名int& c = b;//值相同，地址也相同cout << "a = " << a<< endl; cout << "b = " << b << endl;cout << "c = " << c << endl << endl;cout << "&a = " << &a << endl;cout << "&b = " << &b << endl;cout << "&c = " << &c << endl;return 0;
}

在这里插入图片描述

2.2 引用的使用场景

2.2.1 引用做参数

最典型的例子就是我们经常使用的交换函数：


//a是x的别名，b是y的别名。a,b的交换就是x,y的交换
void Swap(int& a, int& b)
{int tmp = a;a = b; b = tmp;
}int main()
{int x = 1;int y = 2;Swap(x, y);//这里就不用传地址过去了cout << x << ":" << y << endl;return 0;
}

2.2.2 引用做返回值

这里暂时不解释，到后面学习了类和对象后再解释，会更加清晰。

2.3 引用特性

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

第1，2条容易理解，这里说明第三条：

int main()
{int x = 0;int& y = x;//y是x的别名int z = 1;//这里y是z的别名，还是z赋值给y？//是赋值。引用一旦引用一个实体，就不能再改变指向了！y = z;cout << "x = " << x << endl;cout << "y = " << y << endl;cout << "z = " << z << endl << endl;return 0;
}

在这里插入图片描述

2.4 引用的权限问题

这里所说的权限有：权限放大，权限缩小，权限平移。

2.4.1 举例1

int main()
{//这里权限放大了。m是只读，n变成m的别名后，可读可写。const int m = 0;//int& n = m; //errint p = m;//可以，不是权限的放大。//只是把m拷贝给p，p的修改不影响m。//n也是只读的，权限的平移const int& n = m;//可以return 0;
}

2.4.2 举例2

int main()
{const int m = 0;// 权限的放大//p1可以修改，*p1不行,const修饰的是p1指向的内容，即*p1。const int* p1 = &m;p1++;//可以//int* p2 = p1;//err. *p2是可以修改的，所以权限放大了。return 0;
}

2.4.3 举例3

int main()
{//权限的缩小int x = 0; int& y = x;const int& z = x;//可以y++;//x,z都会修改return 0;
}

2.4.4 总结

1.权限放大问题存在于引用和指针里，普通的赋值拷贝不会。
2.权限只能缩小，平移，不能放大。

2.5 常引用

2.5.1 类型转换时

因为类型转换的过程中会生成临时变量，这个临时变量具有常性(相当于被const修饰)。权限被放大了。

int main()
{double d = 3.24;//类型转换int i = d;//int& r = d;err const int& r = d;//可以。加了const就相当于权限平移了。return 0;
}

2.5.2 表达式运算时

表达式运算也会生成临时变量，解释同上。

int main()
{	int x = 0, y = 1;//表达式运算也会生成临时变量//int& r2 = x + y; //errconst int& r2 = x + y; //可以return 0;
}

2.6 传值、传引用效率比较

其实这与函数的传值，传址调用类似。当函数传值调用时，会在内存中又开辟空间临时拷贝，当参数较大时，效率低下。而传址调用却不会，会提高效率。

#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;
}int main()
{TestRefAndValue();return 0;
}

在这里插入图片描述

注意：0毫米表示运行时间小于1毫米。

2.7 引用和指针的区别

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

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

我们来看下引用和指针的汇编代码对比：

在这里插入图片描述

引用和指针的不同点:

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

三，内联函数

如果有一个频繁调用的小函数，例如Swap交换函数，在频繁调用时会有建立栈帧的消耗，我们想消除这样的消耗，该怎么做呢？

C语言中是使用宏函数解决，C++中就可以使用内联函数。

3.1 内联函数的概念

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

3.2 inline 关键字

在没有加 inline 之前：

 int Add(int x, int y)
{return x + y;
}int main()
{int c = Add(1, 2);cout << c << endl;return 0;
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/a2e02365da664bc89959a7e1cc548147.png

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

inline int Add(int x, int y)
{return x + y;
}int main()
{int c = Add(1, 2);cout << c << endl;return 0;
}

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

在这里插入图片描述

转到汇编中：

在这里插入图片描述

3.3 内联的特性

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

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

在这里插入图片描述

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

四，auto关键字(C++11)

其实 auto 关键字的介绍和使用内容十分丰富，我们现在这个阶段不需要了解太详细，在以后的学习中会边学边了解。

4.1 给类型取别名

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：类型难于拼写，含义不明确导致容易出错。

有人会想到 typedef 不也可以给类型取别名吗？但是在某些场合下是有缺陷的：

typedef char* pstring;int main()
{//const pstring p1;//err. const修饰指针p1本身，//而const修饰的指针要初始化const pstring* p2;  // 可以. const修饰 *p2return 0;
}

4.2 可由初始化自动推导类型

比如，下面的写法是正确的：

int main()
{int i = 0;//根据右边得到初始化自动推导类型auto j = 7;return 0;
}

注意：下面的 typeid(变量名).name 判断一个对象的类型

int TestAuto()
{return 10;
}int main()
{int a = 10;auto b = a;auto c = 'a';auto d = TestAuto();//cout << typeid(b).name() << endl;cout << typeid(c).name() << endl;cout << typeid(d).name() << endl;//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化return 0;
}

在这里插入图片描述

  • 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

4.3 auto不能推导的场景

1.auto不能作为函数的参数。
2.auto不能直接用来声明数组。

五，基于范围的for循环

5.1 范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：

void TestFor()
{int array[] = { 1, 2, 3, 4, 5 };for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)array[i] *= 2;for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)cout << *p << endl;
}

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{int array[] = { 1, 2, 3, 4, 5 };//注意：这里如果要改变原数组元素的值，要加引用&for(auto& e : array)e *= 2;for(auto e : array)cout << e << " ";return 0;
}

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

5.2 范围for的使用条件

1.for循环迭代的范围必须是确定的。
2.迭代的对象要实现++和==的操作。(关于迭代器这个问题，以后会讲，现在提一下，没办法讲清楚，现在大家了解一下就可以了)

六，nullptr关键字

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。

在C语言中，如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void TestPtr()
{int* p1 = NULL;int* p2 = 0;// ……
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void)的常量* 。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/fe6bbcdae8264ae2b7b7771de6e53add.png

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，所以会调用f(int)函数，因此与程序的初衷相悖。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void )0。

注意：
1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

2 在C++11中，sizeof(nullptr) 与 sizeof((void)0)所占的字节数相同。*

3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

这篇关于【C++】：函数重载，引用，内联函数，auto关键字，基于范围的for循环，nullptr关键字的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/921698。

相关文章

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。实现的代码如下： class A class B1:public virtual A; class B2:pu
阅读更多...
C++对象布局及多态实现探索之内存布局（整理的很多链接）

C++对象布局及多态实现探索之内存布局（整理的很多链接）

本文通过观察对象的内存布局，跟踪函数调用的汇编代码。分析了C++对象内存的布局情况，虚函数的执行方式，以及虚继承，等等 文章链接：http://dev.yesky.com/254/2191254.shtml      论C/C++函数间动态内存的传递 (2005-07-30)   当你涉及到C/C++的核心编程的时候，你会无止境地与内存管理打交道。 文章链接：http://dev.yesky
阅读更多...
C++的模板(八)：子系统

C++的模板(八)：子系统

平常所见的大部分模板代码，模板所传的参数类型，到了模板里面，或实例化为对象，或嵌入模板内部结构中，或在模板内又派生了子类。不管怎样，最终他们在模板内，直接或间接，都实例化成对象了。 但这不是唯一的用法。试想一下。如果在模板内限制调用参数类型的构造函数会发生什么?参数类的对象在模板内无法构造。他们只能从模板的成员函数传入。模板不保存这些对象或者只保存他们的指针。因为构造函数被分离，这些指针在模板外
阅读更多...
C++工程编译链接错误汇总VisualStudio

C++工程编译链接错误汇总VisualStudio

目录 一些小的知识点 make工具 可以使用windows下的事件查看器崩溃的地方 dumpbin工具查看dll是32位还是64位的 _MSC_VER .cc 和.cpp 【VC++目录中的包含目录】 vs 【C/C++常规中的附加包含目录】——头文件所在目录如何怎么添加，添加了以后搜索头文件就会到这些个路径下搜索了 include<> 和 include"" WinMain 和
阅读更多...
C/C++的编译和链接过程

C/C++的编译和链接过程

目录 从源文件生成可执行文件（书中第2章） 1.Preprocessing预处理——预处理器cpp 2.Compilation编译——编译器cll ps：vs中优化选项设置 3.Assembly汇编——汇编器as ps：vs中汇编输出文件设置 4.Linking链接——链接器ld 符号 模块，库 链接过程——链接器 链接过程 1.简单链接的例子 2.链接过程 3.地址和
阅读更多...
C++必修：模版的入门到实践

C++必修：模版的入门到实践

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：C++学习 贝蒂的主页：Betty’s blog 1. 泛型编程 首先让我们来思考一个问题，如何实现一个交换函数？ void swap(int& x, int& y){int tmp = x;x = y;y = tmp;} 相信大家很快就能写出上面这段代码，但是如果要求这个交换函数支持字符型
阅读更多...
【操作系统】信号Signal超详解|捕捉函数

【操作系统】信号Signal超详解|捕捉函数

🔥博客主页： 我要成为C++领域大神🎥系列专栏：【C++核心编程】 【计算机网络】 【Linux编程】 【操作系统】 ❤️感谢大家点赞👍收藏⭐评论✍️ 本博客致力于知识分享，与更多的人进行学习交流 ​ 如何触发信号 信号是Linux下的经典技术，一般操作系统利用信号杀死违规进程，典型进程干预手段，信号除了杀死进程外也可以挂起进程 kill -l 查看系统支持的信号
阅读更多...
C++入门01

C++入门01

1、.h和.cpp 源文件 (.cpp)源文件是C++程序的实际实现代码文件，其中包含了具体的函数和类的定义、实现以及其他相关的代码。主要特点如下：实现代码: 源文件中包含了函数、类的具体实现代码，用于实现程序的功能。编译单元: 源文件通常是一个编译单元，即单独编译的基本单位。每个源文件都会经过编译器的处理，生成对应的目标文件。包含头文件: 源文件可以通过#include指令引入头文件，以使
阅读更多...
java中查看函数运行时间和cpu运行时间

java中查看函数运行时间和cpu运行时间

android开发调查性能问题中有一个现象，函数的运行时间远低于cpu执行时间，因为函数运行期间线程可能包含等待操作。native层可以查看实际的cpu执行时间和函数执行时间。在java中如何实现？ 借助AI得到了答案 import java.lang.management.ManagementFactory;import java.lang.management.Threa
阅读更多...
SQL Server中，isnull（）函数以及null的用法

SQL Server中，isnull（）函数以及null的用法

SQL Serve中的isnull()函数：          isnull(value1,value2)         1、value1与value2的数据类型必须一致。         2、如果value1的值不为null，结果返回value1。         3、如果value1为null，结果返回vaule2的值。vaule2是你设定的值。        如
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2