C++ Primer（第 5 版）：“16.3 重载和模板”在其所有“更专业”的示例中是否错误？

Question

C++ Primer（第 5 版） - 重载和模板 - 第 16.3 节，教授在存在候选函数模板实例化的情况下的函数匹配过程。

以下是本节中使用的函数模板的声明：

using std::string;
template <class T> string debug_rep(const T &); /* 1 */
template <class T> string debug_rep(T *);       /* 2 */
// definitions not relevant for the questions

 第一个例子

string s("SO");
debug_rep(&s);

然后说生成的实例化将是：

1. debug_rep(const string *&)（T 绑定到 string *）
2. debug_rep(string *)

Q1 #1 是否正确？它不应该实例化debug_rep(string* const &) 吗？

 第二个例子

const string *sp = &s;
debug_rep(sp); //string literal type is const char[10]

然后说生成的实例化将是：

1. debug_rep(const string *&)（T 绑定到 const string *）
2. debug_rep(const string *)

因此，两个实例化的候选者都将提供完全匹配，在更专业的模板上进行选择 (-> #2)

Q2.1 #1 是否正确？它不应该实例化debug_rep(const string* const &)吗？

Q2.2 假设实例化的函数就是上面那个，我们可以确定它不再是完全匹配了吗？

 第三个例子

debug_rep("SO world!"); //string literal type is const char[10]

然后说生成的实例化将是：

1. debug_rep(const T &)（T 绑定到 char[10]）
2. debug_rep(const string *)

因此，两个实例化的候选者都将提供完全匹配，在更专业的模板上进行选择 (-> #2)

Q3.1 #1 中为T 推断的类型是否正确？不应该是const char[10]吗？

Q3.2 假设T 的推导类型实际上就是上面那个，我们可以确定它不再是完全匹配了吗？

Answer 1

你得到了这些声明：

using std::string;
template <class T> string debug_rep(const T &); /* 1 */
template <class T> string debug_rep(T *);       /* 2 */

---

在调用中

string s("SO");
debug_rep(&s);

&s 产生一个string*，当T 为string* 时，它只能匹配(1) 的T const&。对于 (2) 中的 T*，有一个匹配 T 绑定到 string。所以，如果你的引用是正确的，这本书是错误的

debug_rep(const string *&)

作为一个可能的实例化：没有这样的。

T = string* 产生的实例化将改为

debug_rep( string* const& )

但是会调用哪个实例化呢？

作为一般规则，最简单的匹配更好，但我从来没有记住确切的规则，所以，我问 Visual C++（因为它的typeid(T).name() 默认产生可读的类型名称）：

#include <iostream>
#include <string>
#include <typeinfo>
using namespace std;

template< class T >
struct Type {};

template <class T> auto debug_rep( T const& )   // 1
    -> string
{ return string() + "1 --> T = " + typeid(Type<T>).name(); }

template <class T> auto debug_rep( T* )         // 2
    -> string
{ return string() + "2 --> T = " + typeid(Type<T>).name(); }

auto main() -> int
{
    string s( "SO" );
    cout << debug_rep( &s ) << endl;
    cout << "The type 'int const' is shown as " << typeid(Type<int const>).name() << endl;
}

它说：

2 --> T = struct Type,class std::allocator > 类型“int const”显示为 struct Type

对于你的第二个和第三个例子等等：显然作者对const有一些混淆。

Answer 2

编辑：感谢 Alf 的回答，以及在使用 typeid 时保存有关类型的完整信息的优雅技巧，我能够编写一个程序来解决我的大部分问题（从std::string 更改为int 以提高输出可读性。）
完整代码可编辑运行rextester online IDE。

让我们定义一些类和方法：

template <class> class Type{}; // Allowing to get full type information with typeid
 
template <class T> std::string typeStr()
{ return typeid(Type<T>).name(); }

template <class T> void debug_rep(const T &a) /* 1 */
{
    std::cout << "[1] T type is: "    << typeStr<T>()
              << "\t| arg type is: " << typeStr<decltype(a)>() << std::endl;
}

template <class T> void force_1(const T &a)   /* 1 */
{
    std::cout << "[forced 1] T type is: "    << typeStr<T>()
              << "\t| arg type is: " << typeStr<decltype(a)>() << std::endl;
}

template <class T> void debug_rep(T *a)       /* 2 */
{
    std::cout << "[2] T type is: "    << typeStr<T>()
              << "\t| arg type is: " << typeStr<decltype(a)>() << std::endl;
}

示例 1

跑步：

std::cout << "---First example---" << std::endl;
int i = 41;
debug_rep(&i);
force_1(&i);

显示：

---First example---
[2] T type is: class Type<int>  | arg type is: class Type<int *>
[forced 1] T type is: class Type<int *> | arg type is: class Type<int * const &>

Q1：可以说，当我们调用force_1时，实例化了#1对应的模板，参数类型为int * const &，所以书不正确，实例化的候选# 1 会是

1. debug_rep(int* const &)

示例 2

跑步：

std::cout << "---Second example---" << std::endl;
const int *ip = &i;
debug_rep(ip);
force_1(ip);

显示：

---Second example---
[2] T type is: class Type<int const >   | arg type is: class Type<int const *>
[forced 1] T type is: class Type<int const *>   | arg type is: class Type<int const * const &>

Q2.1：调用force_1，我们注意到参数类型将是int const * const &，所以这本书在参考文献中缺少 const 限定。实例化的候选者实际上是：

1. debug_rep(const int * const &)

Q2.2 第二个候选者是debug_rep(const int *)，它与ip（指向常量整数的指针）完全匹配。要检查第一个候选人的排名是否较低，让我们编写：

void debug_rep_plain_b(const int * const &)   /* 1 */
{ std::cout << "[plain 1]" << std::endl;}

void debug_rep_plain_b(const int *)           /* 2 */
{ std::cout << "[plain 2]" << std::endl; }

如果我们尝试编译：

debug_rep_plain_b(ip)

歧义调用存在编译错误：所以 Q2.2 的答案是否定的，仍然是完全匹配！对于模板化版本，编译器实际上使用了关于最专业模板的规则来解决歧义。
即使推导的候选项有错误，本书是正确的，因为该示例使用最专业的模板说明了重载解决方案。

示例 3

跑步：

std::cout << "---Third example---" << std::endl;
const int ia[3] = {1, 2, 3};
debug_rep(ia);
force_1(ia);

显示：

---Third example---
[2] T type is: class Type<int const >   | arg type is: class Type<int const *>
[forced 1] T type is: class Type<int const [3]> | arg type is: class Type<int const (&)[3]>

Q3.1 CL 推导出T 的类型是const 整数数组，所以会误读。

BUT 结果与 GCC 或 Clang 不一致，会输出：

---Third example---
[2] T type is:4TypeIKiE | arg type is: 4TypeIPKiE
[forced 1] T type is:4TypeIA3_iE    | arg type is: 4TypeIRA3_KiE

有趣的部分是：
[强制1] T型为：4TypeIA3_iE
这意味着他们将 T 推断为 3 个 非-const 整数的数组（因为 _i，而不是 _Ki），这与本书一致。

这个问题我得再开一个问题，我看不懂GCC和Clang操作的类型推导...