分配对局部变量的引用，如果局部变量超出范围，它会超出范围吗？

Question

首先我认为以下绝对是未定义的行为：

Object & foo(){
    Object o;
    return o;
}

Object & ref = foo();

但是现在假设一个函数引用另一个将存在更长时间的对象，并将该引用分配给局部变量，并且局部变量超出范围。这个对象的引用是否也会随着局部变量的销毁而被销毁？

class b {
public:
    int val;
    
    b& round() {
        val += 2;
        return *this;
    }

    int operator+(int i) const{
       return val + i;
    }
};

template<typename T>
class A {
public:
    typedef typename std::vector<b>::const_reference const_reference;
    typedef typename std::vector<b>::reference reference;

    vector<b> _a;
    A() {
        _a.resize(10);
    }

    inline const_reference set() const {
         return  _a.at(0);
    }

    inline reference set()  {
        return  _a.at(0).round();
    }
};

void func1(A<int>& a) {
    b tmp = a.set();
    tmp.val = tmp.val + 2;
    cout << a._a[0].val << endl;
}

int main() {
    A<int> a;
    a.set();
    func1(a);
    cout << a._a[0].val << endl;
}

对_a[0] 的引用基本上分配给func1 中的tmp。

我这样做是因为我担心_a[0] 会因为tmp 超出范围而被破坏，但是我想返回一个引用以便我可以将它用作左值，将右值直接分配给它，喜欢做

a.set() = 1;

还有一点是我不得不写另一个set() const函数并返回一个const引用。

我不得不在另一个set 中编写const 关键字，因为在另一个函数中，例如func2，我将输入作为const vector 引用传递，但我的用法并没有修改它。但是，如果没有 set() const 方法，编译器会在调用 func2（输入、输出）时出错。

没有匹配函数调用'const vector类型的对象。参数的类型为const，但方法未标记为const。

void func2(const vector<A>& input, vector<A>& output) {
    int sum = input[0].set() +2;
}

对我来说，涉及const 规则的事情变得非常棘手。所以为了解决这种情况，我想先把input[0].set()复制到本地的tmp，再做加法。

所以回到原来的问题：

包含引用的局部变量会在超出范围时破坏引用本身吗？即b tmp = a.set(); 当tmp 超出func1 的范围时，a 或a._a[0] 或a._a[0] 上的任何更改也将被释放，因为tmp 是对a._a[0] 的引用？

请原谅我太冗长了...当我知道并尝试学习模板编程和 C++ 的常量时，事情变得非常复杂和艰难...所以我试图灵活地有时使用@987654349 @ 作为左值赋值的参考，有时我也想将它用作右值。

Answer 1

这取决于函数中的局部变量是定义为变量还是引用。请参阅以下示例：

#include <iostream>

class Object{
public:
  Object(){};
  ~Object(){};
};

Object & foo(Object & obj){
    Object& o = obj;
    std::cout << &o << std::endl;
    return o;
}

Object & foo2(Object & obj){
    Object o = obj;
    std::cout << &o << std::endl;
    return o;
}

int main() {
  Object obj;
  std::cout << &obj << std::endl;
  Object & ref = foo(obj);
  std::cout << &ref << std::endl;
  Object & ref2 = foo2(obj);
  std::cout << &ref2 << std::endl;
}

导致以下输出：

# g++ -o main .\main.cpp && ./main
0x61feb7
0x61feb7
0x61feb7
0x61fe8f
0

如果您在函数内部创建本地引用，您将返回对原始对象的引用，该引用在函数离开后仍然存在。 另一方面，如果您正在像foo() 那样进行复制，那么您当然会返回一个已超出范围并因此已被销毁的变量的引用。

如果您想修改现有对象，您可以使用本地参考。但是如果你想创建一个副本并修改它的值，你最好通过移动语义返回它。但请确保真正使用移动语义而不是复制构造函数。请参阅以下示例：

#include <iostream>

class Object{
public:
  Object(){};
  ~Object(){};
};

Object  foo(Object & obj){
    Object o = obj;
    std::cout << &o << std::endl;
    return o;
}

int main() {
  Object obj;
  std::cout << &obj << std::endl;
  Object ref = foo(obj); // move semantic
  std::cout << &ref << std::endl;
  Object ref2;
  ref2 = foo(obj); // copy constructor
  std::cout << &ref2 << std::endl;
}

输出如下

# g++ -std=c++11 -o main .\helloWorld.cpp && ./main
0x61febe
0x61febd
0x61febd
0x61febf
0x61febc

编辑
为了回答来自 cmets 的 OP 问题，我编辑了我的答案。

您不能将“地址”更新为引用指向的对象。这是 C++ 的设计。见：Why are references not reseatable in C++

您只能更新引用指向的对象的值。见：

#include <iostream>

void foo(int& a){
  int b = 20;
  int&c = b;
  std::cout << "Address of C " << &c << " with " << c << std::endl;
  a = c; // does not copy the addres of C into a, but it's value
  std::cout << "Address of a " << &a << " with " << a << std::endl;
}

int main() {
  int a=10;;
  std::cout << "Address of a " << &a << " with " << a << std::endl;
  foo(a);
  std::cout << "Address of a " << &a << " with " << a << std::endl;
}

输出：

Address of a 0x61febc with 10
Address of C 0x61fe88 with 20
Address of a 0x61febc with 20
Address of a 0x61febc with 20

如果您想通过引用更改指针。那么refrence也需要持有一个指针。见：

#include <iostream>

void foo(int*& a){
  int b = 20;
  int* c = &b;
  std::cout << "Address of c " << &c << " pointing to " << c  << " with " << *c << std::endl;
  a = c; // copys the address stored in C into a. Now you have a possible memory leak.
  std::cout << "Address of a " << &c << " pointing to " << c  << " with " << *c << std::endl;
}

int main() {
  int * a = new(int);
  *a = 10;
  std::cout << "Address of a " << &a << " pointing to " << a << " with " << *a << std::endl;
  foo(a);
  std::cout << "Address of a " << &a << " pointing to " << a  << " with " << *a << std::endl;
}

这会导致以下输出：

Address of a 0x61febc pointing to 0x10d1738 with 10
Address of c 0x61fe88 pointing to 0x61fe8c with 20
Address of a 0x61fe88 pointing to 0x61fe8c with 20
Address of a 0x61febc pointing to 0x61fe8c with 17635044 // since b got destroyed the address a holds does not contain the expected value

但你真的不应该做后一个。这很可能会导致内存泄漏（至少）、未定义的行为或打开黑洞。