C++ 基础特性：重载、引用、内联、auto 与 nullptr 的用法和注意点

参数顺序不同，只要类型不完全一样，也能重载。

#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++能支持重载，是因为编译器在背后按函数符号修饰规则把参数类型信息编进了函数名里。用gcc编译C文件不会改变函数名，但用g++编译C++代码时，函数修饰名就变了，从而区分开了不同的重载版本。

引用

引用是给一个变量起个外号，操作这个外号就等于操作原变量。它和原变量共用同一块内存地址，不额外分配空间。

用法很简单：int a = 0; int& b = a;。声明引用时必须初始化，之后不能再让它引用别的变量。一个变量可以有多个引用，同一作用域里引用名不能重复。

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

引用最常用的地方是函数传参，既能直接修改实参，又避免了值传递拷贝大对象的开销。比如swap用引用就比指针传参看着简洁。

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

传递指针时，也可以用引用简化：void Swap(int*& a, int*& b) 相当于传递指针的引用，避免了二级指针。

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

引用做返回值时，返回的是原变量的别名，不会产生临时拷贝。但要格外小心：不能返回局部变量的引用，因为函数一结束局部变量就析构了，引用会悬空。

值传递和引用传递的效率差异是巨大的。下面这个例子里，一个包含大数组的结构体A，值传递循环10000次耗时远高于引用传递。

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

常引用（const引用）可以绑定到临时对象或常量，但会禁止通过该引用修改值。记住：权限可以缩小（普通变量可以被const引用绑定），但不能放大（const变量不能被非const引用绑定）。类型转换产生的临时对象具常性，只能用const引用。

引用和指针经常被拿来比较，它们各有各的适用场景，没有谁能完全替代谁：

1. 引用是别名，指针存地址。
2. 引用必须初始化，指针不必。
3. 引用绑定后不能更改，指针可以再指向别处。
4. 没有空引用，但有NULL指针。
5. sizeof引用得到的是引用类型的大小，sizeof指针永远是指针本身的大小。
6. 引用自增就是原变量加1，指针自增是偏移一个类型大小。
7. 指针可以有多级，引用不能。
8. 访问时指针需要解引用，引用自动解引用。
9. 引用用起来通常更安全些，但指针不可缺少。

内联函数

inline 关键字建议编译器在调用处直接展开函数体，省去函数调用的开销。它适合短小、频繁调用的函数。

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

和宏相比，内联函数有类型检查，可调试，没有多次求值的问题。但宏强制展开，可能会让代码膨胀；内联函数展不展开由编译器决定。

常见的函数调用流程包括保存现场、跳转、恢复现场，内联则直接省去这些步骤。但注意，inline只是一个建议，编译器会根据函数体是否复杂（例如含循环、递归）等因素判断是否真的展开。而且内联函数的定义通常必须放在头文件中，并且声明和定义不能分离，否则链接时可能找不到函数体。

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

在范围for循环中使用auto非常普遍，带引用时可以修改元素，不带引用则只是拷贝。

#include <iostream>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    
    for (auto e : arr) {
        cout << e << " ";
    }
    cout << endl;
    
    for (auto& e : arr) {
        e *= 2;
    }
    
    for (auto e : arr) {
        cout << e << " ";
    }
    return 0;
}

范围for循环要求迭代的范围是确定的。对数组而言，编译器会自动取首个元素和末尾之后的位置；但如果数组作为函数参数传入，会退化为指针，此时范围for无法工作，因为指针丢失了大小信息。

#include <iostream>
using namespace std;

void TestFor(int array[]) {
    for (auto& e : array) { // 错误：array是指针，无法迭代
        cout << e << endl;
    }
}

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

指针空值 nullptr

以前用NULL表示空指针，但NULL其实就是整数0，容易导致重载时的混乱。C++11引入的nullptr是std::nullptr_t类型，能隐式转换为任意指针类型，但不会转为整型，消除了歧义。使用nullptr不需要包含头文件，而且 sizeof(nullptr) 等于 sizeof((void*)0)。

这些特性在C++里属于基本功，但细节处往往藏着陷阱，理解透彻了，日常写代码和面试都踏实很多。