C++ 核心基础特性详解：重载、引用、内联、auto 与 nullptr

3. 参数顺序不同 参数类型相同，名字相同，但顺序不同也构成重载。

#include <iostream>
using namespace std;

void process(int a, double b) {
    cout << "void process(int a, double b)" << endl;
}

void process(double a, int b) {
    cout << "void process(double a, int b)" << endl;
}

int main() {
    process(1, 1.1);
    process(1.2, 1);
    return 0;
}

注意：函数重载与参数名字是否相同没有关系，只与类型有关。

C++ 支持函数重载的原因 C 语言不支持重载是因为同名函数无法区分。C++ 通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样。在 Linux 环境下，使用 gcc 编译 C 文件，函数名修饰未发生改变；而使用 g++ 编译 C++ 文件，函数名修饰会改变，编译器将函数参数类型信息添加到了修改后的名字中。

引用

定义 引用是变量的别名，让能够通过这个别名来访问和操作原始变量。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

使用方法

1. 引用是已存在变量的别名，通过在变量名前使用 & 符号声明。
2. 引用必须在声明时初始化，且一旦初始化后不能再引用其他变量。
3. 一个变量可以有多个引用。
4. 引用在同一个域不能同名，在不同的域可以同名。

#include <iostream>
using namespace std;

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

使用场景

1. 引用传递允许函数直接修改实参的值，避免值传递的拷贝开销（输出型参数）。

#include <iostream>
using namespace std;

void Swap(int* a, int* b) {
    int tmp = *a; *a = *b; *b = tmp;
}

void Swap(int& a, int& b) {
    int tmp = a; a = b; b = tmp;
}

int main() {
    int x = 0, y = 1;
    cout << x << " " << y << endl;
    Swap(x, y);
    cout << x << " " << y << endl;
    return 0;
}

2. 通过引用传递指针与通过指针的指针传递。

#include <iostream>
using namespace std;

void Swap(int*& a, int*& b) {
    int* tmp = a; a = b; b = tmp;
}

void Swap(int** a, int** b) {
    int* tmp = *a; *a = *b; *b = tmp;
}

int main() {
    int x = 0, y = 1;
    int* px = &x, * py = &y;
    cout << *px << " " << *py << endl;
    Swap(px, py);
    cout << *px << " " << *py << endl;
    return 0;
}

3. 引用做返回值。传值返回一定会生成临时变量，而传引用返回的是原变量的别名，不会产生临时变量，能减少拷贝提高效率。但永远不要返回局部变量的引用或指针。

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

#include <time.h>
#include <iostream>
using namespace std;

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

TestFunc1 的耗时会显著高于 TestFunc2，这是因为值传递需要频繁复制大对象，涉及大量内存操作。而引用传递只需传递指针，无需复制数据。

常引用 常引用是指向常量对象的引用。它的主要作用是在引用对象时，禁止通过该引用对对象的值进行修改，从而保证数据的安全性。

• 权限不能放大：const 变量不能被非 const 引用绑定。
• 权限可以缩小：普通变量可以被 const 引用绑定。
• 类型转换产生的临时对象具有常性，只能用 const 引用绑定。

引用和指针的不同点

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

内联函数

定义 内联函数是一种特殊函数，通过编译器优化减少函数调用开销，提高执行效率。

基本语法 使用 inline 关键字声明，建议编译器将函数体直接替换调用处（类似宏展开）。

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

内联函数 VS 宏

核心作用 普通函数调用流程包括保存上下文、跳转执行、恢复上下文。内联函数直接将函数体代码复制到调用处，避免上述开销，适合短小频繁调用的函数。

编译器处理规则

• inline 是建议，非强制：编译器可能忽略 inline 声明（如函数体复杂、递归调用等）。
• 展开条件：函数体短小，无循环、递归等复杂结构。
• 定义位置：内联函数必须在调用点前被定义（通常放在头文件中），否则链接时可能报错，内联函数的声明和定义不能分离。

auto 关键字

定义 auto 是一个功能强大的类型说明符，它能让编译器自动推导变量的类型，从而显著简化代码。

基本语法 auto 的基本语法是在声明变量时，用 auto 关键字替代具体的类型，编译器会根据初始化表达式自动推导变量的类型。

#include <iostream>
#include <typeinfo>
using namespace std;

int main() {
    auto x = 42; // 推导为 int
    auto y = 3.14; // 推导为 double
    auto z = "hello"; // 推导为 const char*
    auto& ref = x; // 推导为 int&
    const auto& cref = x; // 推导为 const int&
    
    cout << typeid(cref).name() << endl;
    cout << typeid(ref).name() << endl;
    return 0;
}

auto 在数组中的应用 使用 for(auto& e : arr)（带引用）可直接修改原数组元素。使用 for(auto e : arr)（值拷贝）只能读取数据，修改无效。

#include <iostream>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    
    // 依次取数组中的数据赋值给 e，自动迭代，自动判断结束
    for (auto e : arr) {
        cout << e << " ";
    }
    cout << endl;
    
    for (auto& e : arr) {
        e *= 2;
    }
    
    for (auto e : arr) {
        cout << e << " ";
    }
    return 0;
}

范围 for 循环使用的条件 for 循环迭代的范围必须是确定的。对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和 end 的方法。

#include <iostream>
using namespace std;

void TestFor(int array[]) {
    for (auto& e : array) {
        cout << e << endl;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    TestFor(arr);
    return 0;
}

当数组作为函数参数传递时，它会自动退化为指向首元素的指针。指针没有保存数组大小信息（丢失了 sizeof(array)），范围 for 需要知道数组的起始和结束位置。

指针空值（nullptr）

1. 在 C++ 里，NULL 一般被定义成整数 0，它的本质是个整数类型。
2. nullptr：这是 C++11 新引入的关键字，它的类型是 std::nullptr_t。nullptr 能够隐式地转换为任意指针类型，但不能转换为整数类型。
3. 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 作为新关键字引入的。
4. sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。

总结

函数重载、引用、内联函数、auto 和 nullptr 是 C++ 基础核心。重载让同名函数依参数适配场景；引用以别名简化操作、提升效率；内联平衡调用开销与复用；auto 减少类型声明冗余；nullptr 规范空指针。这些特性体现 C++ 在兼容与创新间的平衡，既承 C 语言高效，又添安全便捷。吃透并活用它们，是进阶高阶特性的基石，也能轻松应对面试基础考点，助你扎实迈入 C++ 之门。