如何防止 C++ 模板的特化？

Question

当我这样做时编译器不会抱怨 ;-)

// Myfile.h
#include <iostream>
#include <vector>

namespace std
{

template<> class vector<int>
{
public:
    vector ()
    {
        std::cout << "Happy Halloween !!!\n";
    }
};

}

有什么方法可以防止类/函数模板的这种不受欢迎的特化？

--编辑--

我只是以 std:: 为例。我正在寻找的是一种防止这种情况发生在任何模板类上的方法。

Answer 1

您所做的是在标准命名空间中专门化标准库类型。

除了一些记录在案的自定义点（std::swap、std::hash）或用户定义类型的特别受限的特化（例如MySmartPtr<T>），这违反了规范并且结果是未定义的行为。

---

编辑：这种违规行为没有强制诊断。

为了让你的图书馆的客户更难搞砸，你可以做这个技巧：

namespace Public {


    namespace Hidden { // DON'T TOUCH THESE!
        template <typename> struct MyType { };
    }

    using Hidden::MyType;

}

现在，尝试在命名空间 Hidden 中专门化 MyType<> 将失败。

Answer 2

不，C++ 语言不提供通用机制，您可以通过该机制说“不允许此模板的特化”。

但这可能无关紧要。对于您的代码已经使用的任何实例化，用户提供的专业化将违反单一定义规则，并且他们的程序可能会像火球一样爆炸。

如果你不在你的库中使用实例化，那么他们做什么并不重要。

这是在 C++ 中您根本无法阻止用户朝自己的脚开枪的情况之一，如果他们选择这样做，责任就在他们身上。

Answer 3

alias template 不能专门化，并且具有类模板所需的行为。

template<class T>
struct my_class_implementation_which_should_not_be_used_directly
{
    // impl
};


template<class T>
using my_class = my_class_implementation_which_should_not_be_used_directly<T>;

此外，您应该记录专门化my_class_implementation_which_should_not_be_used_directly 会导致未定义的行为。现在您的库用户不能意外地专门化 my_class 并直接警告带有丑陋名称的类。

Answer 4

编辑：

您可以在 C++11 中使用 enable_if 防止模板的特化。但这是不切实际的。

#include <type_traits>

template<
  typename real_t,
  typename = typename std::enable_if<
    std::is_floating_point<real_t>::value
  >::type
>
struct check_t;

template<
  typename real_t,
  typename = typename
    std::enable_if<
      std::is_floating_point<real_t>::value,
      check_t<real_t>
    >::type
>
class vec_t
{

};

#if 1
template<>
class vec_t<int> {};

template<>
class vec_t<int,check_t<int>> {};
#endif

void test()
{
    vec_t<float> vecf;
    vec_t<int> veci;
}

link

main.cpp:26:16: error: no type named 'type' in 'struct std::enable_if<false, void>'

Answer 5

防止此类行为的最佳方法是通过编码标准和代码审查。

在这种情况下，您不能强制编译器出错（除了使用其他答案中建议的解决方法），因为该行为实际上是语言允许的，尽管它的真正用处可能会受到质疑。 问题是 - 您很可能希望/需要为多种类型提供通用行为（因此使用模板），但您需要为某些允许的类型（特别是 std::string）提供特定的实现

一个快速而肮脏的例子（它是一个函数，但同样适用于类）可能如下：

template<typename TData> TData GetData(std::string argument)
{
    std::stringstream stream;
    TData retVal;
    stream.str(argument);
    stream >> retVal;
    return retVal;
}

然而，这会因 std::string 而失败，因为 >> 运算符会在第一个空格之后停止。所以你可以提供一个专门的专业。

template<> std::string GetData(std::string argument)
{
    return argument;
}

Answer 6

有几种方法可以解决这个问题。您可以声明特定的特化而不定义它们。例如：

template<> struct MyStruct<int>;

这样，如果有人试图用一个 int 实例化，他们会得到这个特化，它不会编译，因为有 n 个定义。然后，您可以编写一个简单的宏来为您不希望专门化的所有类型执行此操作。

反之，定义为空：

template<typename T> struct MyStruct{};

然后定义你计划支持的具体类型：

template<> struct MyStruct<int> {...};
template<> struct MyStruct<std::string> {...};
//etc...