如何使用单个return语句返回对变量的引用

Question

Consider the following snippet.

MyType_t& Variable(int i) {
    if (i == 0) {
        return MyVariable0;
    }
    if (i == 1) {
        return MyVariable1;
    }
    return MyDefaultVariable;
}

This will return a reference to a variable that can then be modified.

Variable(1) = 10;

However, our coding standard says to use a single point of return. How would I accomplish this? For some reason, the following seems to only copy the value (thus not returning a reference to the root variable), even though I've verified stepping through code it sets var to the appropriate variable. This would be simple with pointers, but I just can't get the references right.

MyType_t& Variable(int i) {
    MyType_t& var = MyDefaultVariable;
    if (i == 0) {
        var = MyVariable0;
    }
    if (i == 1) {
        var = MyVariable1;
    }
    return var;
}

---

Notes

The returned variable has a global scope (its on an embedded system).

The function is used as a convenience method inside a class, with very limited use/scope.

Answer 1

Your reference is bound to MyDefaultVariable and you cannot modify it afterwards, because that's how it works. Your var = MyVariable0; effectively called MyDefaultVariable 's copy operator, which results in the behavior you observed.

If you want to avoid using a ternary operator here, you can use something close to what you suggested, but using a pointer later dereferenced within the return statement.

MyType_t& Variable(int i) {
    MyType_t* var = &MyDefaultVariable;
    if (i == 0) {
        var = &MyVariable0;
    }
    if (i == 1) {
        var = &MyVariable1;
    }
    return *var;
}

Answer 2

If you want your function to remain readable while adding more variables, I would discourage the use of reference/ternary operators. Pointers would be the way to go.

MyType_t& Variable(int i)
{
MyType_t* var = &MyDefaultVariable;

if (0 == i)
    var = &MyVariable0;
else if (1 == i)
    var = &MyVariable1;

return *var;
}

Answer 3

You could use the conditional operator :

MyType_t& Variable(int i) {
    return ( i==0 ) ? MyVariable0 : ( i==1) ? MyVariable1 : MyDefaultVariable;
}

However, a coding standard that forces you to write unreadable code does not deserve to be called "coding standard" imho.

Answer 4

std::reference_wrapper will provide this functionality without exposing you to the risk of raw pointers. using reference_wrappers also expresses intent.

Note that assigning a new reference to a std::reference_wrapper will cause the wrapper to rebind, it will not overwrite the contents of the referred-to variable.

#include <functional>

using MyType_t = int;
extern int& MyDefaultVariable;
extern int& MyVariable0;
extern int& MyVariable1;


MyType_t& Variable(int i) {
    auto var = std::ref(MyDefaultVariable);
    if (i == 0) {
        var = MyVariable0;
    }
    if (i == 1) {
        var = MyVariable1;
    }
    return var;
}

Another way to express this would be:

MyType_t& Variable(int i) 
{
    auto var = std::ref(MyDefaultVariable);
    switch(i)
    {
        case 0: var = MyVariable0; break;
        case 1: var = MyVariable0; break;
        default: break;
    }
    return var;
}