C++：能否禁止const引用参数绑定临时对象？如何实现无拷贝参数语义？

Great question! Let's break this down into two clear parts to address both of your concerns:

1. Is there a function parameter semantic that guarantees: "the function won't modify the parameter, AND no copy/temporary object will ever be created when calling the function"? #

Short answer: There's no native C++ parameter type that directly checks both boxes out of the box, but we can get close with some extra safeguards, or switch to a different parameter style.

Let's unpack the requirements:

• No modification to the parameter: The standard way to signal this is with const (either const T& or const T*).
• No copies/temporaries ever: This means we only accept existing T lvalues—no implicit conversions (like const char* to std::string) that create temporaries, and no temporary objects passed directly.

Here are your practical options:

• Use a const T* pointer: When you pass a pointer to an existing T, no temporary is created, and const guarantees the function won't modify the underlying object. The tradeoff is that callers have to pass an address (e.g., f(&my_string)), and you'll need to add checks if you want to disallow nullptr (since pointers can be null).
• Use const T& with compile-time checks: While const T& allows binding to temporaries by design, you can add static assertions or template tricks to block rvalues (including temporaries) at compile time. This keeps the clean reference syntax but adds a safety net—we'll cover this in the second section.

The native const T& can't meet both requirements because the C++ standard explicitly allows it to bind to temporary objects (to extend their lifecycle), which is part of its intended design.

2. Can we prevent a const reference parameter from binding to temporary objects? #

Absolutely! Since the standard allows this binding by default, we need to add compile-time checks to block it. Here are two reliable, zero-overhead methods:

Method 1: Delete the rvalue reference overload #

We can create an overloaded version of the function that accepts an rvalue reference (const T&&) and mark it as deleted. This way, any attempt to pass a temporary (or rvalue) will trigger a compile error, while lvalues will work normally:

#include <string>

// Accepts only lvalues (existing std::string objects)
void f(const std::string& str) {
    // Your function logic here
}

// Explicitly block rvalues/temporaries
void f(const std::string&&) = delete;

Now, calling f("hello") will fail: the compiler tries to convert const char* to a temporary std::string (an rvalue), which matches the deleted overload. But std::string my_str = "hello"; f(my_str); works perfectly, with no copies or temporaries.

Method 2: Use static assertions with templates #

If you're writing a template function (or want a generic solution for any type), you can use type traits to check if the argument is an lvalue, and trigger a clear compile error if it's not:

#include <type_traits>
#include <string>

template <typename T>
void f(const T& arg) {
    // Enforce that the argument is an lvalue (not a temporary/rvalue)
    static_assert(std::is_lvalue_v<decltype((arg))>, 
                  "Error: Only lvalues are allowed—no temporary objects!");
    // Your function logic here
}

This works for any type T: if you pass a temporary or rvalue, the static assertion fails with a human-readable message, while valid lvalues proceed without issue.

内容的提问来源于stack exchange，提问作者Ludwig Schulze