C ++：通过成员函数中的引用返回成员变量

Question

Suppose I have the following structure:

class HeavyClass {

    public:
        static inline HeavyClass const &get() { // note the &
            return h_;
        }
    private:
        static HeavyClass h_;
};

HeavyClass HeavyClass::h_();

int main() {
    HeavyClass foo = HeavyClass::get(); // critical line
    return 0;
}

My question is, will this actually do what I want at the critical line? That is, will foo be a copy of h_, or actually h_ as if it's passed by reference?

Many thanks!

Answer 1

I would think you need something like:

const HeavyClass& foo = HeavyClass::get();

If you want foo to be h_ .

Answer 2

You are making a copy.

The function get does indeed return a reference, but you are assigning it by-value:

HeavyClass foo = HeavyClass::get(); // critical line

On the critical line here, the critical part is the definition of foo . foo isn't a reference-to- HeavyClass -- it's a HeavyClass itself. Therefore, foo cannot be a reference to anything.

There is no magic in C++, only logic. Well, OK, maybe there is magic, but none of it is hidden. It;'s all in plain sight. Here you declared a HeavyClass , not a reference-to- HeavyClass , so it doesn't magically become a reference.

If you want a reference, declare foo like this:

const HeavyClass& foo = HeavyClass::get()

By the way, it looks like you're trying to build a Singleton. Please, at least research and be cognizant of all the arguments why Singletons are considered to be generally bad before you continue.

Answer 3

The value of the right-hand side is not relevant for determining the type of the variable, which you have declared to be of type HeavyClass . So a new object of that type is instantiated and initialized with the value on the right. The fact the right-hand side is an lvalue doesn't matter (it will be subjected to lvalue-to-rvalue conversion).

Whether a function's return type is a reference or not doesn't change the value of the function call, only the value category .

Note that this is exactly the same with auto : If you had said auto x = HeavyClass::get(); , it'd be the same, for the same reason ( auto deduces type, not value category).