// old
template <T1, T2, RetT>
RetT add(T1 left, T2 right) { return left + right; }

// new
auto add(auto left, auto right) { return left + right; }

新格式在 clang++ 和 msvc 下 编译通过
clang++：clang++ -std=c++20 xxx.cpp
msvc：msvc /std:c++latest xxx.cpp

文中只讨论了相似性，相似性能比较容易理解语法形式，但是两者的区别能更有助于理解模板吧。

我觉得是不是可以强调一下模板实例化的时候传入的是一个类型（基本类型或者自定义类型），而函数传入的其实是一个值或者一个地址

继续写啊！！！！

#include <iostream>

template <float a>
float qwq()
{
	return a;
}

template <double foo>
double awa()
{
	return foo;
}

int main(int argc, char* argv[])
{
	std::cout << qwq<3.14F>() << '\n'
		<< awa<6.28>() << '\n';
	
	return 0;
}

以上代码编译通过。
IDE：Microsoft Visual Studio Community 2019 16.9.0 Preview 2.0
编译器：msvc（启用 预览 - 最新 C++ 工作草案中的功能 (/std:c++latest)）

停更后只能去看 c++ template了。。希望大佬能更新快点。

RT，风格很难跟类型联想起来。

第383行中，“好吧，"ambigous"，这个提示再明确不过了。”
单词 ambigous 应该是 ambiguous。

// Tuple的一些用例
tuple<int> a;
tuple<double&, const double&, const double, double*, const double*> b;
tuple<A, int(*)(char, int), B(A::*)(C&), C> c;
tuple<std::string, std::pair<A, B> > d;
tuple<A*, tuple<const A*, const B&, C>, bool, void*> e;

这里int(*)(char, int)我知道是一个函数指针的写法，但是B(A::*)(C&)该作何理解呢？A::*是A作用域中的星号？如果那样的话不是应该是operator*吗？

文中还有一句：
“甚至运用模板较多的Boost的”
应为
甚至运用模板较多的Boost

• void_t idiom[1]

template<typename T, typename = void>
struct HasReference : std::false_type {};
template<typename T>
struct HasReference<T, std::void_t<typename T::reference>> : std::true_type {};

[1] CppCon 2014: Walter E. Brown "Modern Template Metaprogramming: A Compendium, Part II"

• type_traits_v
  借助于 C++ 14 的 variable templates：
  is_same_v ...
• constexpr if
  可以干掉 Tag Dispatch：

template<typename Iterator>
Iterator next(Iterator iter, std::ptrdiff_t dist)
{
        using category = typename std::iterator_traits<Iterator>::iterator_category;
        constexpr if(std::is_base_of_v<std::random_access_iterator_tag, category>)
            return iter + dist;
        else constexpr if(std::is_base_of_v<std::input_iterator_tag, category>)
        {
            for(std::ptrdiff_t i = 0; i < dist; ++i)
                ++iter;
            return iter;
        }
 }

• std::conjunction/std::disjunction/std::negation

template<typename... TArgs, typename... UArgs>
struct BeExplicit: std::conjunction<std::is_constructible<TArgs, UArgs>..., std::disjunction<std::negation<std::is_convertible<UArgs, TArgs>>...>> {};

• template<auto>

template <auto x> 
constexpr auto constant = x;

constant<true> c1; 
constant<2> c2;

• 类模板的类型参数推导：

std::tuple t{1, 2.0, "haha"s}; //std::tuple<int, double, std::string>
std::unique_ptr handle{::CreateFile(xxx), [](auto h) noexcept { ::CloseHandle(h); }};

2.2.3 里：

template <typename T> class TypeToID<float>
{
    static int const ID = 0xF10A7;
};

是

template <> class TypeToID<float>
{
    static int const ID = 0xF10A7;
};

么？

class的成员默认为private，为了使两段代码效果相同，似乎应加上public关键字。

2.1节对元编程的解释中，"用更好理解的说法，元编程意味着你撰写一段程序A，程序A会运行后生成另外一个程序B，程序B才是真正实现功能的程序。"，其中“运行”一词是否改为"编译"更恰当?

什么鬼，为毛我的账户显示应该联系你。。。。

2.1
原文“这个问题很功利，但是一阵见血。因为技术的根本目的在于解决需求。那C++的模板能做什么？”

应该是 一针见血

求更新，写的真好，讲得真棒，能将复杂的内容讲清楚是一种很重要的能力，羡慕

建议将所有下划线开头的名字都改一下：

Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

标准是不建议在全局命名空间出现用户自定义的下划线开头符号的

期待更新啊

Github最近新增了一个功能，即Discussions板块，每一个resp都有，默认不开通。
这种文档性质的项目，感觉比较适合开通这个“讨论区”功能，详细的情况可以自己探索下试试。

虽然貌似已经停更了，不过在pending里也木有看到这部分欸。

省得以后找不到，蛤蛤蛤蛤

大佬，求更新，给钱。

B b;                  // B 是第三类名字，b 是第二类

b应该是第一类，这个在下面几行的示例里面写对了，但是前面写错了。

Int8,16: N/A
Int32 : VInt32Mul(int32 * 4, int32 * 4)
Int64 : VInt64Mul(int64 * 2, int64 * 2)
Float : VInt64Mul(float * 2, float * 2)

参数：int32 * 4, int32 * 4 ，2和4做参数是否有错误 ，还是有其他含义？

持续关注中...，盼望更新更快些！
c++模板是我最想掌握的了。现在C++标准都要快到c++17了。很想了解掌握最新特性，比如“变量模板”、“可变参数模板”、“参数及返回值推导”等等。
谢谢，谢谢。

然后你仔细的比较了一下，然后发现 … 模板参数有两个，而参数里面能得到的只有 SrcT 一个。结合出错信息看来关键在那个 DstT 上。这个时候，你死马当活马医，把模板参数写完整了：

float i = c_style_cast<float, int>(v);
嗯，很顺利的通过了。难道C++不能支持让参数推导一部分模板参数吗？

建议在文章最开头加个带链接的目录，不然还要花时间找上次看到哪里了

我之前对template这部分内容了解不多，这份教程对我帮助很大！

但是在3.2章里面有两个地方没有搞明白，希望能得到一些指点。

第一个问题：

但是问题到了这里并没有结束。因为 increase 毕竟是个虚函数。假如 Counter 需要调用的地方实在是太多了，这个时候我们会非常期望 increase 不再是个虚函数以提高性能。此时我们会调整继承层级：

struct ICounter {};
struct Counter: public ICounter {
    void increase() {
        // impl
    }
};

template <typename T>
void inc_counter(ICounter& c) {};

template <typename T>
void inc_counter(T& c) { ++c; };

void doSomething() {
    Counter cntObj;
    uint32_t cntUI32;

    // blah blah blah
    inc_counter(cntObj); // 1
    inc_counter(static_cast<ICounter&>(cntObj)); // 2
    inc_counter(cntUI32); // 3
}

这里基类ICounter是个无用的tag，但是在inc_counter(static_cast<ICounter&>(cntObj)); // 2中，将cntObj转为ICounter后，基类里并没有increase()这个函数呀。要怎么实现计数的功能呢？
所以这个地方没有理解。

第二个问题

仍是上面这份代码里的inc_counter(static_cast<ICounter&>(cntObj)); // 2，想要调用的应该是

template <typename T>
void inc_counter(ICounter& c) {};

这个函数吧？但是这样会报错（用c++11/c++14都试过，估计与c++标准的版本无关）：

error: no matching function for call to 'inc_counter'
inc_counter(static_cast<ICounter&>(cntObj));
^~~~~~~~~~~~

请问这里是想要表达为：

template <typename T>
void inc_counter(T &c) {
}

template <>
void inc_counter(ICounter &c) {
  std::cout << "in ICounter" << std::endl;
}

还是直接：

void inc_counter(ICounter& c) {};

另外，为什么会有这样的报错，我也不是很确定。

望指教，非常感谢！

// TEMPLATE CLASS is_base_of
template<class _Base, class _Der>
struct is_base_of _IS_BASE_OF(_Base, _Der)
{ // determine whether _Base is a base of or the same as _Der
};

Error：
typename std::enable_if<std::is_base_of<T, ICounter>::value>::type* = nullptr)

Right:
typename std::enable_if<std::is_base_of<ICounter, T>::value>::type* = nullptr)

define BIN_OP(type, a, op, b, result) ((type const *)(result)) = ((type const )(a)) op ((type const*)(b))

是否应为:

define BIN_OP(type, a, op, b, result) ((type *)(result)) = ((type const )(a)) op ((type const*)(b))

在 C11 标准中加入了 _Generic 关键字，使得 2.2.1 根据类型执行代码 对 C 的描述可以加入 _Generic 相关的内容

你好。

void poo(){
X::foo();
X::foo();
}

Y误写为X？

continue????

或许修改成：

{   // 以下为 DoWork<int> 查找对应匹配的伪代码
    templateProtoInt = TemplateDict.find(DoWork, int);    // 查找模板原型，查找到(0)
    template = templateProtoInt.match(int);              // 以 int 对应 int 匹配到 (1)
}

{   // 以下为DoWork<float*> 查找对应匹配的伪代码
    templateProtoFloatPtr = TemplateDict.find(DoWork, float*) // 查找模板原型，查找到(0)
    template = templateProtoFloatPtr.match(float*)            // 以 float* 对应 U* 匹配到 (3)，此时U为float
}

会更好理解？