引用仅在constexpr /编译时上下文中有用吗？

Question

I am exploring the world of constexpr and have decided to create a class that should only be used in constexpr context and other compile-time constructs.

Usually, I take great care to provide all necessary overloads a class may need, for example:

template <typename T>
struct Thing
{
    Thing(T value) : m_value(value) {}

    T &value() & { return m_value; }
    const T &value() const & { return m_value; }

    T &&value() && { return std::move(m_value); }

private:
    T m_value;
};

The set of overloads for Thing::value should take care of efficient access to the stored value, no unnecessary copies are made. If the Thing instance is a temporary, the stored value can even be moved out.

But what if Thing is only to be used as a constexpr type, are all these different overloads for Thing::value required or even helpful at all? Or would the following be equivalent:

template <typename T>
struct Thing
{
    constexpr Thing(T value) : m_value(value) {}

    constexpr T value() const;

private:
    T m_value;
};

---

My question basically boils down to: are references helpful (more efficient) when operating in a constexpr/compile-time context only; or is passing everything by value equivalent?

Answer 1

My question basically boils down to: are references helpful (more efficient) when operating in a constexpr/compile-time context only; or is passing everything by value equivalent?

It's a matter of what's your actual problem and how you plan to solve it. In most of the cases (all of them?) you won't need to use references in such a context, I agree, but you can still use them if required.

Here as a minimal, working example:

const int i = 0;

template <typename T>
struct Thing {
    constexpr Thing(const T &value) : m_value(value) {}
    constexpr const T & value() const { return m_value; }

private:
    const T & m_value;
};

int main() {
    static_assert(Thing<int>{i}.value() == 0, "!");
}

See it up and running on wandbox .

So, are references helpful (more efficient) in this case? Well, it's not a matter of efficiency or whatever. To use references in such a context you have to have a good reason and the language sets a lot of limitations. They solve a specific problem, it's not your taste to decide to use references.
If your problem requires you to use references, they are there for you (and please, contact me - I'm just curious to know what's that problem!). Otherwise feel free to keep on with passing by value.