C++ 入门：引用、内联函数与 C++11 新特性详解 | 极客日志

C++

C++ 入门：引用、内联函数与 C++11 新特性详解

C++ 引用作为变量别名共享内存，定义需初始化且不可重绑定。内联函数通过编译期展开减少调用开销，但可能增加代码体积，递归函数通常无法内联。C++11 引入 auto 关键字实现类型推导简化声明，配合指针或引用使用需注意显式符号。基于范围的 for 循环要求迭代对象支持 ++ 和 == 操作。nullptr 替代 NULL 消除重载歧义，明确表示空指针类型。掌握这些基础特性有助于编写高效、安全的现代 C++ 代码。

全栈工匠发布于 2026/3/260 浏览

C++ 入门：引用、内联函数与 C++11 新特性详解

引用

引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如李逵，在家称为铁牛，江湖上人称黑旋风。

void TestRef() {
    int a = 10;
    int& ra = a; // 定义引用类型
    cout << &a << endl;
    cout << &ra << endl;
}

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

引用的特性

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

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    // 1、编译报错：'ra': 必须初始化引用
    // int& ra;
    
    // 2、一个变量可以有多个引用
    int& b = a;
    int& d = a;
    
    // 3、这里并非让 b 引用 c，因为 C++ 引用不能改变指向，这是一个赋值
    int c = 20;
    b = c;
    return 0;
}

常引用

const 引用就是常引用。当 const 引用绑定临时变量时，会延长临时变量的生命周期，使其与 const 引用的生命周期一致，直到该引用（如 rii）的生命周期结束。

使用场景

引用做参数

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

输出型参数：传参时不用担心值拷贝问题，因为形参和实参都指向同一实体。

int& Add(int a, int b) {
    int c = a + b;
    return c; // 错误：返回了局部变量的引用
}

int main() {
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :" << ret << endl;
    return 0;
}

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

#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;
    // 1、以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 1000000; ++i) TestFunc1(a);
    size_t end1 = clock();
    
    // 2、以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 1000000; ++i) TestFunc2(a);
    size_t end2 = clock();
    
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

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

struct A {
    int a[10000];
};
A a;

// 值返回
A TestFunc1() {
    return a;
}

// 引用返回
A& TestFunc2() {
    return a;
}

void TestReturnByRefOrValue() {
    // 1、以值作为函数的返回值类型
    size_t begin1 = clock();
    for (size_t i = 0; i < 100000; ++i) TestFunc1();
    size_t end1 = clock();
    
    // 2、以引用作为函数的返回值类型
    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;
}

int main() {
    TestReturnByRefOrValue();
    return 0;
}

int main() {
    int a = 10;
    int& ra = a;
    cout << "&a = " << &a << endl;
    cout << "&ra = " << &ra << endl;
    return 0;
}

int a = 10;
auto b = a; // 编译器推导出 b 的类型为 int
auto c = 'c'; // 推导出 c 的类型为 char

int x = 20;
auto* p1 = &x; // p1 推导为 int*
auto p2 = &x;  // p2 同样推导为 int*

int y = 30;
auto& r = y;   // r 推导为 int&（y 的引用）
auto r2 = y;   // r2 推导为 int（y 的值拷贝）

auto a = 10, b = 20; // 正确，a 和 b 均推导为 int
// auto c = 10, d = 3.14; // 错误，c 推导为 int，d 推导为 double，类型不一致

// 编译失败：auto 不能作为函数参数类型
void func(auto param) { }

int arr[] = {1, 2, 3};
// auto arr2[] = {4, 5, 6}; // 错误，auto 不能直接声明数组
auto* p = arr; // 正确，p 推导为 int*（指向数组首元素）

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

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

void TestFor(int array[]) {
    for (auto& e : array) cout << e << endl; // 数组退化为指针，无法计算范围
}

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

void f(int) {
    cout << "f(int)" << endl;
}
void f(int*) {
    cout << "f(int*)" << endl;
}
int main() {
    f(0);      // 调用 f(int)
    f(NULL);   // 可能调用 f(int)，取决于 NULL 定义
    f((int*)NULL); // 明确调用 f(int*)
    return 0;
}