Assigning reference to local variable, would it go out of scope if the local variable is out of scope?

Question

First I think the following is definitely Undefined Behavior:

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

Object & ref = foo();

But now suppose a function that takes a reference of another object which will exists longer, and assign this reference to a local variable, and the local variable gets out of scope. Would the reference of this object also be destroyed as the local variable is destroyed?

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

Basically reference to _a[0] is assigned to tmp in func1.

I am doing it this way because I have concerns that _a[0] would be destroyed as tmp goes out of scope, But I want to return a reference so that I can use it as an lvalue, assigning rvalues directly to it, like doing

a.set() = 1;

Another point is that I am forced to write another set() const function and return a const reference.

I am forced to write the const keyword in another set because in another function, for example func2, I passed input as a const vector reference, but my usage is not modifying it. However, without the set() const method, the compiler errors when calling func2 (input,output).

No matching function for call to object of type 'const vector<A>.The argument has type const but the method is not marked const.

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

To me, things involving const rules become very tricky. So to solve this situation, I am thinking of copying input[0].set() to a local tmp first and do the addition.

So going back to the original question:

Would the local variable containing the reference destroy the reference itself when it goes out of scope? i.e. b tmp = a.set(); when tmp is out of scope from func1, nothing changes on a or a._a[0], or a._a[0] would also be released because tmp is a reference to a._a[0]?

Excuse me for being verbose... things are getting very complex and tough by the time I know and try to learn template programming and const of C++... So I am trying to have the flexibility to sometimes use the set() as a reference for lvalue assignment and sometimes I also want to use it just as an rvalue.

Answer 1

It depends if the local variable within your function is defined as variable or as a reference. See the following example:

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

which results in the following outpout:

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

If you create a local reference inside your function you will return a reference to the original object, which still exists after the function is left. On the other hand if you are doing a copy as in foo() of course you will return a reference of a variable which has gone out of scope and therefor has been destroyed.

If you want to modify an existing object you could go for a local reference. But if you want to to create a copy and modify it's values you better return it by move semantics. But make sure to really use move semantics instead of copy constructor. See the following example:

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

with the following output

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

Edit
To answer the OP's questions from the comments I edited my answer.

You cannot update the "address" to an object a reference points to. That's by design of C++. See: Why are references not reseatable in C++

You can only update the value of an object a reference points to. See:

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

with the output:

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

If you want to change a pointer via a reference. Then the refrence also needs to hold a pointer. See:

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

Which results in the following output:

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

But you should really not do the later one. This will most likely cause a Memory leak (at least), undefined behaviour or open a black hole.