九(3).引用作为方法别名返回

1. 基本概念

在 C++ 中，引用作为方法的返回值（即返回一个引用）是一种常见但需要谨慎使用的技巧。它允许函数返回对内部数据的引用，从而避免拷贝开销，但同时也带来了生命周期和可修改性的问题。

(1) 返回引用的含义

• 函数返回一个引用时，返回的是对某个对象的别名（即该对象的另一个名字），而不是对象的副本。

• 调用者可以通过返回的引用直接操作原始对象（如果引用是非 const 的）。

(2) 语法示例

class MyClass {
public:
    int value;
    MyClass(int v) : value(v) {}

    // 返回非 const 引用（允许修改内部数据）
    int& getValue() { 
        return value; 
    }

    // 返回 const 引用（只读访问）
    const int& getValue() const { 
        return value; 
    }
};

int main() {
    MyClass obj(42);
    int& ref = obj.getValue();  // ref 是 obj.value 的别名
    ref = 100;                  // 修改了 obj.value
    std::cout << obj.value;     // 输出 100

    const int& cref = obj.getValue();  // 只读访问
    // cref = 200;               // 错误！不能修改 const 引用
}

2.返回引用 vs 返回值区别

3.几种使用方式的总结

引用型的返回值，从函数中返回引用，一定要保证在函数返回后，该引用的目标依然有效

(1) 可以返回 全局变量，静态变量的引用

int mml = 1;  // 全局变量

int& mmll()
{
    return mml;
}

int main()
{
    cout << "Address: " << &mml << " , mml = " << mml << endl; // Address: 00007FF6263E4004 , mml = 1
    
    // mmll() 最后返回的就是mml的别名
    mmll() = 67;  // Address: 00007FF6263E4004 , mml = 67

}


int& bar()
{
    static int g_bar = 10;

    cout << "Address: " << &g_bar << " , g_bar = " << g_bar << endl;

    return g_bar;
}

int main()
{
    
    // bar() 最后返回的就是g_bar的别名
    bar() = 35;  // Address: 00007FF6A20E4008 , g_bar = 10
    //可以这样理解  int& ref = bar();①  ref = 35 ②
    // 2. ​赋值操作的本质​
	当执行 bar() = 35; 时：
	​调用 bar()：返回 g_bar 的引用（相当于 int& ref = g_bar;）。
	​通过引用赋值：ref = 35; 直接修改 g_bar 的值。
    

	bar();  // Address: 00007FF6A20E4008 , g_bar = 35
}

(2) 可以返回成员变量的引用（类）

class Counter {
private:
    int count = 0;
public:
    int& getCount() { 
        return count;  // 返回非 const 引用，允许外部修改
    }
};

int main() {
    Counter c;
    c.getCount() = 100;  // 直接修改私有成员
    std::cout << c.getCount();  // 输出 100
}

(3)  可以返回在堆中动态创建的对象的引用

int& hum()
{
    static int* p = new int(5);

    cout << "Address: " << p << ", *p = " << *p << endl;

    return *p;
}

--> 这种可能会出现问题 每次调用都 new 一个新内存,可以从地址看到两次调用都是新 new 的对象
int& hum1() {
    int* p = new int(5); // 每次调用都 new 一个新内存
    return *p;
}

int main() {
 
    // hum() 最后返回的就是p的别名
     hum() = 109;  // Address: 0000017313A8AA10, *p = 5

	 hum();   //  Address: 0000017313A8AA10, *p = 109
    
    // hum1() 最后返回的就是p的别名
    hum1() = 109;  //  Address: 0000012FCE5BAA10, *p = 5
    
    hum1();    // Address: 0000012FCE5BAA10, *p = 5
}

(4)  可以返回调用对象自身的引用 (类)

(5)  可以返回引用型参数本身

int& func(int& x)
{
    return x;  // 返回引用型参数本身
}

int main()
{
    int a_val = 3;
    
    // func(a_val) 的返回值就代表 a_val本身，32就存到a_val中
    func(a_val) = 32;  
    
     cout << "a_val: " << a_val << endl;  // a_val: 32
}

(6) 不能返回局部变量的引用

• 后果：返回的引用指向已销毁的内存，访问它会导致未定义行为（崩溃或数据损坏）。

• 正确做法：

  • 返回值（拷贝）而非引用。

  • 使用静态局部变量（但需注意线程安全）。

  • 返回动态分配的对象（需手动管理内存，不推荐）。

int& getLocalVariable() {
    int x = 42;  // 局部变量
    return x;    // 错误！x 在函数结束后被销毁
}

4.总共有两大类的返回类型

• 非常引用(没有const修饰)类型返回值

  • 通过引用可以修改目标

int& func(int& x)
{
    return x;  // 返回引用型参数本身
}


int main()
{

    int a = 10;
    func(a) = 30;  // OK，可以修改

}

• 常引用(const修饰)型返回值

  • 通过引用不能修改目标

const int& func(int& x)
{
    return x;  // 返回引用型参数本身
}

int main()
{

    int a = 10;
    func(a) = 30;  // ERROR，不可以修改

}

返回 const 引用以保护内部数据

• 如果不希望外部代码修改内部数据，返回 const 引用：

class SafeData {
public:
    int value = 42;
    const int& getValue() const { 
        return value;  // 只读访问
    }
};

int main() {
    SafeData data;
    const int& ref = data.getValue();
    // ref = 100;  // 错误！不能修改 const 引用
}

 ​