C++ 模板：以简御繁-1/5

cmake_minimum_required(VERSION 3.12)
project(makeString VERSION 0.1.0)
add_executable(makeString main.cpp)

set(CMAKE_CXX_EXTENSIONS OFF)      # no vendor-specific extensions
set_property(TARGET makeString PROPERTY CXX_STANDARD 20)

# Ask a compiler to be more demanding（对编译器更高的要求）
if (MSVC)
    target_compile_options(makeString PUBLIC /W4 /WX /Za /permissive-)
else()
    target_compile_options(makeString PUBLIC -Wall -Wextra -pedantic -Werror)
endif()

2.2 一些测试代码来理解目标

让我们添加几个用例：假设我们有结构体 A 和 B。A 是一个没有数据的标签，而 B 包含一个整数。这里使用结构体而不是类的唯一原因是为了节省一些 public: 可见性说明符所占用的屏幕空间。

#include <iostream>
#include "makeString.hpp"

struct A
{
    std::string to_string() const { return "A"; }
};

struct B
{
    int m_i = 0;
    std::string to_string() const { return "B{" + std::to_string(m_i) + "}"; }
};

int main()
{
    A a;
    B b = {1}; // 复制列表初始化将m_i 初始化为1

    std::cout << "a: " << makeString(a) << "; b: " << makeString(b)
              << std::endl;
}

2.3 makeString.hpp 中的一个简单模板

最后，一个简单的模板。

#pragma once
#include <string>

template <typename Object>
std::string makeString(const Object& object)
{
    return object.to_string();
}

现在我们可以构建它、运行它并看到输出：a：A；b：B{1}。

这段代码其实存在一些问题，现在我们假装没有发现任何问题，直到它们在文章后续部分的实际使用过程中出现。

3. 函数模板的特化

如果我们想将 int 转换为字符串该怎么办？

int main()
{
    A a;
    B b = {1};

    std::cout << "a: " << makeString(a) << "; b: " << makeString(b)
              << "; pi: " << makeString(3)
              << std::endl;
}

当然，上面的代码会导致编译错误，因为没有针对整数的 to_string() 方法。幸运的是，我们可以提供一个模板特化，指定 makeString<int> 应该有一个特殊的实现。我们来试试：

// rather an attempt, than a solution
template <> std::string makeString(int i)
{
    return std::to_string(i);
}

对吗？不对。编译器找不到匹配的模板，因为模板参数中唯一允许特化的部分是 Object 参数：

template <typename Object> std::string makeString(const Object& object)

可以用 int 替换 Object，但不能删除 const 和&引用限定符。因此，正确的做法可能是：

// template specialization: Object = int
template <> std::string makeString(const int& i)
{
    return std::to_string(i);
}

好吧，虽然上面的函数能正常工作，但它违反了“按值传递低成本复制类型”的准则。按值传递不仅成本更低，而且更容易优化。查看 Arthur O’Dwyer 的博客，了解更多关于 string_view 示例的见解。

4. 模板函数的重载

模板函数和非模板函数都参与重载。函数模板参考资料会提供很多见解，函数模板调用的重载解析一文中有几个简单的例子，但目前总结一下就足够了：在重载解析过程中，为了找到最佳匹配，模板函数和非模板函数都会被考虑。

// not a template. This will be the best match for makeString(3),
// unless we explicitly specify that we want a template: makeString<int>(3)
std::string makeString(int i)
{
    return std::to_string(i);
}

现在我们可以放弃 const int& 特化，编译、运行并享受重载的 makeString(int) 和 pi 的近似值：a: A; b: B{1}; pi: 3

对于那些需要精确度的人，我们可以添加更多的重载：

// main.cpp
// ...
    std::cout << "a: " << makeString(a) << "; b: " << makeString(b)
              << "; pi: " << makeString(3) << "; pi(double): " << makeString(3.1415926)
              << std::endl;

在下面的文件中进行函数重载

// makeString.hpp
//...
std::string makeString(float f)       { return std::to_string(f); }
std::string makeString(double d)      { return std::to_string(d); }
std::string makeString(long double d) { return std::to_string(d); }
// ... 5 more specializations ...

5. 从多个实现中选择一个模板

5.1 问题

在编写上述复制粘贴代码的过程中，读者可能会想到创建一个单独的模板。然而，当编译器不确定在像 makeString(3) 这样的调用中应该实例化哪个模板时，就会出现问题，从而导致编译失败。如果有一个模板和普通函数都可以matrch的话，不会出现问题，优先选择普通函数。

template <typename Object>
std::string makeString(const Object& object)
{
    return object.to_string();
}

template <typename Numeric>
std::string makeString(Numeric value)
{
    return std::to_string(value);
}

/*
main.cpp:21:40: error: call of overloaded ‘makeString(int)’ is ambiguous
 |               << "; pi: " << makeString(3)
 |                              ~~~~~~~~~~^~~
  note: candidate: std::string makeString(const Object&) [with Object = int;]
  note: candidate: std::string makeString(Numeric) [with Numeric = int;]
*/

编译错误，这是因为makeString(3)既可以match makeString(const Object&) [with Object = int;]，也可以match makeString(Numeric) [with Numeric = int;]。

在重载解析期间，编译器仅检查函数声明，要求开发人员提供一种仅使用函数声明来区分重载的方法。

作为一般规则，我会考虑限制所有模板函数，以防止编译器为不兼容的类型实例化它们。遵循此规则可以避免在添加新的模板函数重载时出现可扩展性问题。

剧透：如果我们提前阅读了concept（概念）部分，我们几乎可以像使用上面的代码一样使用。

// concepts HasToString, IsNumeric, and IsString should be defined above

template <HasToString Object>
std::string makeString(Object&& object)
{
    return std::forward<Object>(object).to_string();
}

std::string makeString(IsNumeric auto value)
{
    return std::to_string(value);
}

template <IsString String>
std::string makeString(String&& s)
{
    return std::string(std::forward<String>(s));
}

为了更深入地了解模板，我们将继续使用 SFINAE：这是一种更详细的解决方案，在 C 20 中出现这些concept（概念）之前就很流行。但是，急于继续阅读的读者可以跳过本节，直接进入完美转发章节，然后再了解concept（概念）。

5.2 SFINAE，一种更难的、C++20 之前的方法

在重载解析过程中，如果无法将模板参数替换为一个具体的参数，编译器将忽略该模板声明。这个概念被称为“替换失败并非错误”。

运用智慧和一点想象力，想出两个解决方案：

将 object.to_string() 成员函数调用结合到 std::string makeString(const Object& object) 的模板声明中，以阻止这次替换 [Object = int]
确保 std::string makeString(Numeric value) 的声明涉及 std::to_string(value)，以阻止在不支持 std::to_string 重载的情况下进行类型替换，而不是让编译器在后续的编译函数体的时候报错。

几种可能的解决方案

5.2.1. 让类型参数依赖`to_string()成员函数的结果`

// will match only types with to_string() member function
template <typename Object,
          typename DummyType = decltype(std::declval<Object>().to_string())>
std::string makeString(const Object& object)
{
    return object.to_string();
}

上面的代码使用了与 Object::to_string() 成员函数类型相同的 DummyType。如果这个类型不存在 Object::to_string() ，替换将失败，从而将这个模板函数排除在重载解析之外。

5.2.2. 后置返回类型：在替换期间访问函数参数名称

有人可能会问，为什么不使用参数变量名来强制执行 SFINAE？因为从语法上讲，我们在函数参数定义之前就强制执行了它。使用后置返回类型，我们可以将 SFINAE 推迟到函数参数声明的位置。

这是我最喜欢的使用 C++ 17 的 SFINAE 方法

// makeString.hpp
#pragma once
#include <string>

template <typename Object>
auto makeString(const Object& object) -> decltype(object.to_string())
{
    return object.to_string();
}

template <typename Numeric>
auto makeString(Numeric value) -> decltype(std::to_string(value))
{
    return std::to_string(value);
}

这里，自动返回类型强制编译器检查后置的返回类型，因此它会检测 -> 右侧表达式的类型，例如 decltype(object.to_string())。如果替换失败，该函数将从重载候选列表中删除。就这么简单。

有一个 std::enable_if 模板可以解决同样的问题，但在我看来，它更冗长。因此，我建议等到真正需要的时候再使用它。

再次编译、运行，然后尽情享受吧：a: A; b: B{1}; pi: 3; pi(double): 3.141593。我们花了一些时间，它看起来运行良好，我认为这是一个好的开始。