// 引用: 必须是有效对象的别名，不能为空，不能重新绑定
int x = 42;
int& ref = x;    // ref 是 x 的别名
// int& null_ref; // 错误: 引用必须初始化
// ref = y;       // 这是赋值，不是重新绑定

// 指针: 可以为空，可以重新指向
int* ptr = &x;   // ptr 指向 x
ptr = nullptr;   // OK: 指针可以为空
int y = 100;
ptr = &y;        // OK: 指针可以重新指向

// 语法差异:
*ptr = 10;  // 需要解引用
ref = 10;   // 直接使用

// 底层实现:
// 引用通常用指针常量实现: int* const ref = &x;
// 但编译器可以做更多优化（如直接替换为原变量）

// 使用引用的场景:
// 1. 函数参数（避免拷贝，表达"不为空"的语义）
void process(const std::string& name);  // 不修改，不拷贝
void modify(std::vector<int>& data);    // 需要修改

// 2. 操作符重载
std::ostream& operator<<(std::ostream& os, const Widget& w);

// 3. 返回左值
int& getFirstElement(std::vector<int>& vec) {
    return vec[0];  // 返回引用，允许修改
}

// 使用指针的场景:
// 1. 可能为空
Widget* findWidget(int id) {
    // 可能找不到，返回 nullptr
}

// 2. 需要重新指向
Widget* current = nullptr;
for (auto& w : widgets) {
    if (w.isActive()) {
        current = &w;  // 指向不同的 widget
        break;
    }
}

// 3. 数组操作
void processArray(int* arr, size_t size) {
    for (size_t i = 0; i < size; ++i)
        arr[i] *= 2;
}

// 错误: 返回局部变量的引用
const std::string& getGreeting() {
    std::string greeting = "Hello";
    return greeting;  // greeting 在函数结束时销毁！
}

// 正确: 返回值（利用移动语义）
std::string getGreetingSafe() {
    std::string greeting = "Hello";
    return greeting;  // 移动构造或 NRVO
}

// 正确: 返回成员变量的引用
class Config {
    std::string name;
public:
    const std::string& getName() const { return name; }  // OK: 成员变量生命周期足够长
};

#include <benchmark/benchmark.h>

// 引用版本: 编译器更容易优化
void addRef(const int& a, const int& b, int& result) {
    result = a + b;
}

// 指针版本: 编译器需要处理别名问题
void addPtr(const int* a, const int* b, int* result) {
    *result = *a + *b;
}

// 引用版本通常生成更高效的代码
// 因为编译器知道引用不会为空，不会有别名问题