C++ C++；模板化类型检查编译时线程安全？

有一种检查类型是否匹配的标准方法：

template<class T, class U>
struct is_same { static const bool value = false; };

template<class T>
struct is_same<T, T> { static const bool value = true; };

模板
结构是相同的{static const bool value=false；}；
模板
结构是相同的{static const bool value=true；}；

我是这样用的：

if (SamTypeCheck<double,double>::value)
    cout<<"same"<<endl;
else
    cout<<"different"<<endl;

if (SamTypeCheck<int,double>::value)
    cout<<"same"<<endl;
else
    cout<<"different"<<endl;

if（SamTypeCheck:：value）
库特
在我看来，这不是线程安全的，因为它使用静态成员变量

它使用静态常量成员变量（“常量变量”…^^^^让我们说“静态成员常量”）。通常所说的“非线程安全”是静态可变变量（“可变”意味着“非常量”，不一定用关键字
mutable
定义）

有时可以看到带有
enum{value=0}的代码（或
1
）而不是
静态常量值=false
（或
true
），但它通常被认为是一种“黑客”行为，您将失去
bool
类型

另外，在C++11中，直接从标题
使用

在我看来，这不是线程安全的，因为它使用静态成员变量

它使用静态常量成员变量（“常量变量”…^^^^让我们说“静态成员常量”）。通常所说的“非线程安全”是静态可变变量（“可变”意味着“非常量”，不一定用关键字
mutable
定义）

有时可以看到带有
enum{value=0}的代码（或
1
）而不是
静态常量值=false
（或
true
），但它通常被认为是一种“黑客”行为，您将失去
bool
类型

另外，在C++11中，直接从头使用
。
正如前面在注释中所述，这些都是编译时检查，因此线程安全不是问题。也就是说，您应该始终在类型检查中使用继承，因为它是一种更好/更优雅的设计（后面是标准库实现）

差不多

 template<typename U, typename T> struct is_same : public std::false_type {};
 template<typename T> struct is_same<T, T> : public std::true_type {};

模板结构是相同的：public std:：false\u type{}；
模板结构是相同的：public std:：true\u type{}；

std:：true/false类型包含std:：integral_常量“value”
正如前面在注释中所述，这些都是编译时检查，因此线程安全不是问题。也就是说，您应该始终在类型检查中使用继承，因为它是一种更好/更优雅的设计（后面是标准库实现）

差不多

 template<typename U, typename T> struct is_same : public std::false_type {};
 template<typename T> struct is_same<T, T> : public std::true_type {};

模板结构是相同的：public std:：false\u type{}；
模板结构是相同的：public std:：true\u type{}；

std:：true/false类型包含std:：integral_常量“value”
，因为答案可能不明显，请注意，对is_相同结构成员的每次访问都是在编译时计算的，因此没有任何线程不安全行为的空间。因为答案可能不明显，请注意，对is_same结构成员的每次访问都在编译时进行评估，因此没有任何线程不安全行为的空间。静态成员不是一个好的设计。使用继承（尽管如注释中所述，这些都是编译时检查-对于线程安全来说不是问题）静态成员不是一个好的设计。使用继承（尽管如注释中所述，这些都是编译时检查-对于线程安全来说不是问题）