C++入门（下）

C++入门（下）

前言：

上章博客我们讲了函数重载的内容，这一章我们继续对函数重载的内容进行补充。然后继续对引用进行讲解。现在附上上篇博客的链接，没看过上篇博客的兄弟们，一定要去看了上篇再来学习这一篇

1.函数重载补充

函数重载这章，在后面面试时，面试官有可能会提出问题，今天我们就拿出两个比较经典的问题进行讲解。

1.1为什么C语言不支持重载？C++支持？C++底层是如何支持重载

在讲解这个问题之前，我们得先了解编译链接的过程：

一般我们编写程序时，会有一个f.h头文件，我们会在其中进行各种宏的编写和进行函数的声明，然后我们会有f.cpp文件，对函数进行编写，最后我们还需要一个main.cpp文件进行主函数的编写。当我们将这三个文件写好后，允许程序，会进行以下四个过程。

• 预处理–在这个阶段我们将头文件展开、宏替换、去掉注释和条件编译

  随后生成两个文件 f.i 和 main.i

• 编译 – 这个阶段会检查语法、生成汇编代码 f.s 和 main.s

• 汇编– 这个阶段我们会把汇编代码转成二进制机器码 生成文件 f.o 和main.o

• 链接 – 将所有文件链接到一起，生成可执行程序 a.out

为什么要了解这个过程，因为只有了解了这个过程，才能理解接下来所讲述的。

main.cpp在编译链接的过程中，只有声明，没有具体的函数，会把运用的函数命名一个名称，然后后面包含它的地址。链接时再去找函数的定义。所以在链接前面的阶段，有了声明，编译器就会认为函数定义在其他地方，就会通过编译，在链接时再去寻找函数的定义。这也是为什么我们需要写函数的声明。

了解了上面的过程，我们就需要了解C是怎么处理函数的了，C语言是直接拿函数名直接做名称，如果定义重载。编译器就不知道你用的究竟是哪个函数了，因为在编译器看来函数的名称都一样

而C++为了能使用函数重载，增加了一个函数名修饰规则，支持函数重载，C++中的所有函数都使用这个函数规则

如：

int Add(int a,int b);

在运用C++函数名修饰规则转换后，

这个时候我们发现，其定义函数重载后，不同函数的区别就在参数上，所以这也是为什么函数重载的定义要求其参数一定不同。

这就很好的解释了为什么C不支持函数重载，C++支持，C++底层是如何实现函数重载的

2.extern “c”作用是什么?

看的这个问题，很多人一年疑惑，这个问题与函数重载有什么关系，我们继续往下看。

首先我们又要介绍一个新概念， 中间件程序–通常我们把它编译成静态库或动态库。那这又是什么意思呢？

实际上就相当于用C++写提供几个接口函数给使用者

1.那么介绍这个有什么用呢，对这个问题，继续往下看。

我们讲了C++对函数有自己的命名规则，而接口函数，是已经被编译出来的指令，所以C将不能调用这些接口函数了，但万一我们就要用C使用这些函数呢？

这个时候加上extern “c”这个函数将会被用作C语言的命名规则处理，但我们说C++兼容C，所以这个时候这个接口函数，C和C++都可以使用。

如：

extern "c" void* a(int a,int b);

注：加了extern “c”将不能重载，相当于回归了C语言

2.又有人会问了，谁会在C++中写C的程序呢，当然有了

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “c”,告诉编译器，将该函数按照C语言规则来编译

2.引用

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

如：

int a = 10;
int& b = a;
//b是a的引用（别名）

1.注：

void swap(int& r1,int& r2);

void swap(int r1,int r2);

问：这两个函数重载吗？

这两个函数肯定不是重载，会报错，因为第一个函数和第二个函数参数类型都为int，不构成重载函数的条件。加上&符号只是相当于给r1和r2起了别名，对它的类型int没有影响

2. 引用必须初始化，告诉它是谁的别名

如：

int a = 10;
int& b = a;
int c = 20;
b = c;
//不是让b变为c的别名，而是将c的值赋值给b，也相当于赋值给a

3.权限缩小和权限扩大问题

• 权限扩大问题

const int a = 10;
int& ra = a;

上面会报错的

因为const int a是不可修改的，不能只写int& ra，这样它又变成可修改的了。所以得写成

const int a = 10;
const int& ra = a;

所以权限放大是不行的

• 权限缩小问题

int b = 10;
int& b = b;
const int& crb= b;

这可以，crb引用b属于权限缩小，是可以运用的。

4.隐式类型转换

• 普通类型

  int c = 10;
  double d = 1.11;
  d = c;
  

  其转换时，会在中间创建一个临时变量，这个临时变量为转换成浮点型的c，再赋值给d，c的值不会发生变化

只有类型有偏差，其中就会产生一个临时变量

• 引用类型

  int c = 10;
  double d = 1.11;
  const double& rc = c;
  

  问：

  为什么要加const，rc是谁的别名呢？

  加const是因为临时变量具有常性，不可修改，而rc指向的是d和c之间创造的临时变量。

5.引用做返回值

• 传值返回

  int Add(int a,int b)
  {
      int c = a + b;
      return c;
  }
  

这个返回也是，创建一个临时变量返回，而不是直接c拷贝过去，所以虽然c只存在Add函数中，函数销毁，其将不存在。但其是传给临时变量，那个临时变量还存在，将可以继续赋值给主函数需要的值，所以传值返回是可行的。

之所以设置成这样，也是因为c是存在函数中的临时变量，如果直接拷贝。其已经被销毁，将出现问题

• 传引用返回

  int& Add(int a,int b)
  {
      int c = a + b;
      return c;
  }
  int main()
      Ç
      int& d = Add(1,2)ë
      return 0;
  

  

这样传引用会出现问题，因为中间创建的临时变量，也是c的别名。所以当返回去后，d也是c的别名，都是指向c的。而c是临时变量，已经被销毁了。所以这样虽然能返回到3，但函数已经销毁，其所属空间已经不为c所有。所以ret可能为3或任何值。其返回实际是越界访问

所以一般不能用引用作为返回值，除非其出了作用域还在

如：

static int c = a + b;

• 传值、传引用效率比较

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

  当参数和返回值是比较大的变量时，传引用传参和传引用做返回值。还可以提高效率，只要符合条件，尽量用引用传参，传返回值

3.内联函数

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

因为建立栈帧有开销，所以C语言也提供了宏函数支持，在预处理阶段展开

1.1问：既然C语言已经解决了，为什么C++还要提供inline函数函数呢？（宏函数的缺点）

• 不支持调式
• 容易出错，宏函数语法复杂
• 没有类型安全的检查

2.1特性

• inline是一种以空间换取时间的的做法，省去调用函数额外开销。所以代码很长，或者有循环、递归的函数不适宜使用作为内联函数
• inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环递归等，编译器优化会忽略内联
• inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址了，链接会找不到

3.1C++哪些技术代替宏

• 常量定义，换用const
• 短小函数定义，换用内联函数

4.auto

1.1引入：

如：

int main()
{
    int a = 10;
    auto b = a;
}

类型声明成auto，可以根据a的类型自动推导b的类型

int a = 10;
auto c = &a;
auto* d = &a;
//用这两个当成指针都可以，都是int*类型
int& y = a;
//类型为int，是a的引用
auto& z = a;
//类型为int，但z为a的引用

2.2注意：

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出的类型去定义其他变量

void TestAuto()
{
    auto a = 1,b = 2;
    auto c = 3,d = 4.0;
    //下面这一行是错误的
}

3.1auto不能推导的场景

• auto不能作为函数的参数。

  void TestAuto(auto a)
  

  此处代码编译失败，auto不能作为形参类型，编译无法对a的实际类型进行推导

• auto不能直接用来声明数组。

  int a = {1,2,3};
  auto b = {4,5,6};
  //这样是错误的
  

• 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

• auto在实际中常见的，优势用法就是跟C++11提供的新式for循环，还要lambda表达式等进行配合使用

5.指针空值nullptr

1.1 C++98中的指针空值

int* p1 = NULL;
int* p2 = 0;

NULL实际上是一个宏，在传统的C文件（.h）中

#define NULL 0

NULL可能被定义为字面常量0，或者被定义为无类型指针（void）的常量**

2.1 可能出现的问题

void f(int a)
{
    cout << "f(int)" << endl;
}

void f(int* a)
{
    cout << "f(int*)" << endl;
}
int main()
{
    f(0);
    f(NULL);
}
//会报错，程序实际上想通过f(NULL)调用指针版本的(int*)函数，但是由于NULL被定义为。所以实际编译器不知道你要调用哪个函数

3.1nullptr的一些使用注意事项

• 在使用nullptr表示指针空值，不需要包含头文件。nullptr是C++作为新关键字引入的
• 在C++中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同
• 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr