C++编译器，强制通过引用传递

Question

Is it possible to set as default a C++ compiler to interpret all parameter passing as being by-reference defining a new modifier to specify that you need a passage by copy.

Programming I found that only rerely I need to pass data by copy so, at least for me, would be much more effective to have "reference by default"

Answer 1

Not only there isn't such a feature, there can never be one . Doing so would make well-defined programs ill-formed or worst, having Undefined Behaviour.

Consider this simple well-formed program:

struct X {};

auto bar(X x) -> decltype(x)
{
    return x;
}

auto test()
{
    bar(X{});
}

How would you transform it? There is no way to make bar take reference and not change the semantics of the program or make it UB

If you make bar take l-value reference then it can't accept a temporary:

struct X {};

auto bar(X& x) -> decltype(x)
{
    return x;
}

auto test()
{
    bar(X{});
}

 <source>:12:5: error: no matching function for call to 'bar' bar(X{}); ^~~ <source>:4:6: note: candidate function not viable: expects an l-value for 1st argument auto bar(X& x) -> decltype(x) ^ 1 error generated.

If you make it take an r-value reference then you cannot return it without further modifications:

struct X {};

auto bar(X&& x) -> decltype(x)
{
    return x;
}

auto test()
{
    bar(X{});
}

 <source>:6:12: error: rvalue reference to type 'X' cannot bind to lvalue of type 'X' return x; ^ 1 error generated.

Ok, you can solve this particular problem by moving the parameter. But that is well beyond what you initially set to change. Nevertheless, for the sake of the argument let's say you do, or that the original program was already doing it:

#include <utility>

struct X { };

auto bar(X&& x) -> decltype(x)
{
    return std::move(x);
}

auto test()
{
    bar(X{});
}

This finally indeed compiles. But do you see the problem? You return a reference to an expired object, you return a dangling reference:

// before

#include <utility>

struct X { auto foo() const {} };

auto bar(X x) -> decltype(x) // bar returns a prvalue
{
    return x;
    // or
    // return std::move(x); // redundant, but valid and equivalent
}

auto test()
{
    const X& xr = bar(X{}); // xr prolongs the lifetime of the temporary returned by `bar`

    xr.foo(); // OK, no problem
}

// after

#include <utility>

struct X { auto foo() const {} };

auto bar(X&& x) -> decltype(x) // now bar returns an xvalue
{
    return std::move(x);
}

auto test()
{
    const X& xr = bar(X{}); // xr cannot prolong the life of an xvalue
    // the temporary objects created as part of calling `bar` is now expired
    // and xr references it
    // any attempt to use xr results in UB

    xr.foo(); // Undefined Behaviour
}

There is no way to do what you want to do.

The burden is on you, the programmer: if you need values write values, if you need references write references. It's as simple as that.

Answer 2

No.

I haven't heard of any compiler having this feature.