从C到C++，C++入门（2）

在C++入门篇（1）中，博主为大家简单介绍了什么是C++，以及C++中的关键字，命名空间，输入与输出和缺省参数的相关知识。今天就让我们继续一起学习C++的基础知识点吧！！

1.函数重载

1.1函数重载的概念

在自然语言中，一个词可以有多重含义，人们可以通过上下文来判断这个词语的真实含义。举一个简单的例子：“读书好，读好书，好读书” 中三个“好”的意思是完全不同的，即该词被重载了。
函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数/参数类型/类型顺序）不同，常用来处理实现功能类似但数据类型不同的问题
C语言是不允许同名函数的存在的
但在C++里，不同作用域里的函数可以重名，同一作用域里的函数也可以重名，但要满足重载条件

1.2函数重载的条件

参数类型不同

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

参数个数不同

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

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

参数类型顺序不同

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

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

大家有没有思考过为什么C语言不支持函数重载，但是C++却支持函数重载呢？

C语言不支持函数重载是因为C语言是一种过程式编程语言，它的设计初衷是简洁高效，不包含太多复杂的特性。在C语言中，函数的标识符是唯一的，不允许同名函数存在，因此无法实现函数重载

C++支持函数重载是通过名字修饰（Name Mangling）来实现的。在C++中，当定义多个同名函数但参数列表不同的函数时，编译器会根据函数的参数类型、个数和顺序生成不同的函数名，这个过程就叫做名字修饰。

名字修饰的过程会将函数名和参数列表信息结合起来，生成一个唯一的函数名，这样就能区分不同的重载函数。在调用函数时，编译器会根据函数名和参数列表来选择调用哪个函数。

举个例子，假设我们有两个重载的函数：

void print(int num);
void print(double num);

在编译过程中，编译器会对这两个函数进行名字修饰，生成类似以下的函数名：

print_int
print_double

这样，即使这两个函数具有相同的函数名，但由于它们的参数类型不同，在生成的函数名中会包含参数类型信息，从而能够区分这两个函数。

总之，C++支持函数重载是通过名字修饰来实现的，编译器会根据函数的参数类型和个数生成不同的函数名，从而实现了函数重载的特性。

2.引用

2.1引用的概念

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

比如：李逵，在家称为“铁牛”，江湖上人称“黑旋风”。别名就相当于一个人的外号

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

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

void TestRef()
{
  int a = 10;
  int& ra=a;//定义引用类型
  printf("%p\n",&a);
  printf(%p\n",&a);//两个地址打出来是一样的
}

2.2引用的特性

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

void TestRef()
{
  int a = 10;
 //int& ra;没有初始化，这条语句在编译的时候会出错
  int& ra=a;//ra是a的别名
  int& rra = a；//rra也是a的别名
  printf("%p %p %p\n",&a,&ra,&rra);
}

引用出错举例

谨记：权限可以平移和缩小，但不能放大

void TestConstRef()
{
  const int a = 10;
//int& ra=a;该语句编译时会出错，a本不可修改，现在通过ra可以修改a了，权限扩大了
  const int& ra = a；//这种是合法的
  
  double d=12.34;
//int& rd = d;该语句编译时会出错，因为类型不同
}

int main()
{
  double d = 12.34;
  //类型转换会生成临时变量，实际将临时变量给了i
  int i= d；
  int& r = d；//错误写法，因为临时变量具有常性，不能随便改，这样写导致了权限的扩大
  const int& r = d；//正确
  return 0；
}

给指针变量取别名

int* p1=&x;
int*& pr=p1;
pr= NULL;

2.3使用场景

做参数

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

做返回值

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

2.4传值传引用效率对比

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

2.5引用和指针的区别与联系

联系：在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但是在底层实现上引用是有空间的，因为引用是按照指针方式来实现的。总结：引用和指针在底层都开空间，但是引用从语法角度看不开空间，从底层看两者都开空间。

区别：

引用概念上定义一个变量的别名，指针存储一个变量地址
引用在定义时必须初始化，指针没有要求
引用在初始化引用一个实体以后就不能再引用其他实体，然而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
两者在sizeof中含义不同，引用结果为引用类型的大小，但是指针始终是地址所占字节个数
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
两者访问实体方式不同，指针需要显示解引用，引用编译器会自己处理
引用比指针使用起来相对安全一些

3.内联函数

3.1内联函数的定义

在C++中，内联函数是一种特殊的函数，它会在每个调用点上被直接插入到程序中，而不是通过函数调用的方式进行执行。这样可以减少函数调用建立栈帧的开销，提高程序的执行效率。

要定义一个内联函数，需要在函数的声明和定义前面加上关键字inline

inline int add(int a, int b) {
    return a + b;
}

在上面的例子中，inline关键字告诉编译器将add函数作为内联函数进行处理。当函数被调用时，它的代码会被直接插入到调用点上，而不是通过函数调用的方式执行。

3.2特性

inline是一种以时间换空间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。
好处是少了调用开销，提高程序运行效率。坏处是可能会使目标文件变大。
inline对于编译器而言只是一个建议，不同编译器对于inline的实现方式可能不同，编译器可以选择忽略该请求
通常情况下，内联函数适合用于简单的、频繁调用的函数，这样可以减少函数调用的开销。但是对于复杂的函数或者包含循环、递归等复杂逻辑的函数，声明为内联函数可能会导致代码膨胀，反而降低程序的执行效率。
在实际使用中，编译器会根据函数的复杂度和调用频率来决定是否将函数作为内联函数进行处理，因此我们在编写代码时可以根据实际情况考虑是否将函数声明为内联函数

4.auto关键字

4.1概念

在C++11中，引入了auto关键字，用于让编译器自动推导变量的类型。使用auto关键字定义变量时，编译器会根据变量的初始化表达式推导出变量的实际类型。这样可以简化代码，特别是在处理模板类型、迭代器和复杂的迭代器类型时非常有用。

auto x = 10; // 推导x的类型为int
auto d = 3.14; // 推导d的类型为double
auto str = "Hello"; // 推导str的类型为const char*

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    // 使用auto迭代器，编译器会自动推导it的类型为std::vector<int>::iterator
    std::cout << *it << std::endl;
}

std::map<std::string, int> wordCount = {{"hello", 1}, {"world", 1}};
for (auto& kv : wordCount) {
    // 使用auto遍历map，编译器会自动推导kv的类型为std::pair<const std::string, int>&
    std::cout << kv.first << ": " << kv.second << std::endl;
}

auto关键字并不是完全的类型推导，编译器会根据初始化表达式来推导变量的类型，因此在使用auto关键字定义变量时，一定要确保初始化表达式是明确的，否则编译器无法推导出变量的类型。

auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会把auto替换为变量实际的类型

4.2auto的使用细则

1.auto与指针和引用结合起来使用

auto声明指针类型时，auto和auto*没有任何区别，但是用auto声明引用类型时必须加&

int mian()
{
  int x = 10;
  auto a=&x;
  auto* b = &x;
  auto& c = x;
}

2.在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错

void TestAuto（）
{
  auto a=1,b=2;
  auto c=3,d=4.0;//这行代码会编译失败，因为c和d的初始化表达式类型不一样
}

4.3不宜使用auto的场景

1.auto不能作为函数的参数

void TestAuto（auto a）
{
}
//编译失败，因为编译器无法对a的实际类型进行推导

2.auto不能直接用来声明数组

void TestAuto（）
{
  int a[]={1,2,3};
  auto b[]={4,5,6};
}

5.基于范围的for循环

5.1概念

C++11引入了基于范围的for循环（range-based for loop），它提供了一种简洁的语法来遍历容器、数组和其他支持迭代器的对象的元素。基于范围的for循环可以大大简化遍历容器或数组时的代码，同时也更加直观和易读。

语法如下

for (auto element : container) {
    // 对每个元素执行操作
}

在这个语法中，container是一个支持迭代器的对象，例如数组、标准库容器（如vector、list、map等）、字符串等。element是一个迭代器指向的元素的临时变量，它的类型会根据container中元素的类型自动推导。

下面是一个示例：

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto element : vec) {
    std::cout << element << " ";
}

在这个例子中，基于范围的for循环会遍历vec中的每个元素，并将当前元素赋值给element，然后执行循环体中的操作。这样就可以方便地遍历容器中的元素，而不必显式地使用迭代器或者索引。

需要注意的是，基于范围的for循环在遍历容器或数组时是以值的方式进行操作的，如果需要对容器中的元素进行修改，可以使用引用类型来避免值的拷贝

for (auto& element : vec) {
    element *= 2; // 修改vec中的每个元素为原来的两倍
}

5.2使用条件

for循环迭代的范围必须要是确定的：对于数组而言，就是数组中的第一个元素和最后一个元素；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围
迭代的对象要实现++和==的操作

6.指针空值nullptr

6.1出现的原因

在C++中，定义指针空值nullptr的主要原因是为了提供一种更明确、更安全的方式来表示指针不指向任何有效对象或内存位置。在nullptr被引入之前，程序员通常使用NULL宏或者字面值0（或(void*)0在某些上下文中）来表示空指针。但是，这些做法存在一些潜在的问题和不便。

6.2注意点

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

尾声

关于C++入门的相关知识到这里就告一段落了，欢迎大家在评论区提问

点赞+评论+关注是博主持续不断更新优质好文的最大动力！