C++模板实参添加const的作用及三类传参场景疑问

Hey there! Let's break down your questions step by step, starting with the core role of const in template arguments, then diving into your specific scenario questions.

一、const作为移动构造函数模板实参的作用 #

When you include const as part of a template argument (e.g., const T or T const) in a move constructor context, its key purpose is to restrict the types of objects the move constructor can accept:

• Normally, a move constructor takes a T&& (non-const rvalue reference) to take ownership of resources from a non-const object. If you use a const-qualified template argument like const T&&, the constructor can only accept const rvalues. Since const rvalues can't be modified, this constructor rarely performs actual "moving" (which requires altering the original object). Instead, it's typically used as an overload to avoid unintended constructor matches or handle edge cases involving temporary const objects.

二、场景2：为何func<const int* const>(f)能通过？ #

First, let's recap the scenario: func uses a left-value reference parameter T &val_. When we explicitly set T = const int* const, val_ becomes const int* const&—a left-value reference to a const pointer pointing to const int.

Here's why the call works:

1. Implicit pointer conversion: Our argument f is an int* (non-const pointer to non-const int). C++ allows implicit conversion of int* to const int* (this is safe const-correctness, as we're restricting what the pointer can point to).
2. Binding temporaries to const references: The conversion creates a temporary const int* object. A const left-value reference (like const int* const&, where the const modifies the pointer itself) can bind to temporary objects and extend their lifetime.

Compare this to the failed func<const int*>(f) call: Here, T = const int* makes val_ a const int*&—a non-const left-value reference to a pointer pointing to const int. C++ forbids binding temporary objects to non-const left-value references (to prevent accidental modifications of temporaries), hence the error.

三、场景3：为何最后两次func调用仅添加const就能通过？ #

In scenario 3, func uses T &&val_—but this is not a forwarding reference when we explicitly specify the template argument. Forwarding references rely on template argument deduction; when you explicitly set T, T&& becomes a regular rvalue reference.

Let's break down the working calls:

• For func<const int*>(f): We set T = const int*, so val_ is const int*&& (rvalue reference to a pointer pointing to const int). The int* argument f converts to a temporary const int*, which is an rvalue—and rvalue references are designed to bind to rvalues/temporaries.
• For func<const int* const>(f): T = const int* const makes val_ const int* const&& (rvalue reference to a const pointer pointing to const int). Again, the temporary const int* const (derived from f's conversion) is an rvalue that can bind to this rvalue reference.

The failed func<int*>(f) call fails because T = int* makes val_ int*&& (non-const rvalue reference). The argument f is an lvalue, and C++ doesn't allow binding lvalues to non-const rvalue references (you'd need std::move(f) to make it an rvalue).

四、场景3：显式指定模板实参与推导的区别？ #

The "magic" of forwarding references lies in template argument deduction:

• When you don't explicitly set T (e.g., just call func(f)), the compiler deduces T based on the argument's value category:
  • If the argument is an lvalue (like f), T is deduced as int*&. Using reference collapsing rules, T&& becomes int*& && → int*& (a left-value reference).
  • If the argument is an rvalue (like new int(2)), T is deduced as int*, so T&& is int*&& (a right-value reference).

When you explicitly specify T (e.g., func<int*>(f)), you skip deduction entirely. T is fixed to int*, so T&& is strictly int*&&—a regular rvalue reference. Since f is an lvalue, it can't bind to this non-const rvalue reference, hence the error.

内容的提问来源于stack exchange，提问作者Constantinos Glynos