利用类型萃取(Traits)限制函数模版具体化所使用的类型

前阵子碰到一道编程题，一行文本由多个整数构成，代表一个集合，允许存在重复数字，如何判断两行文本代表同一个集合？关于这个问题我直觉想到的是先排序再比较，如果两者size不一样直接返回false，否则再逐个比较，出现不一致的立刻返回false。可以用std::multiset存储读入的数据，其内部是个平衡二叉树结构，插入数据时可以自动排序，且代价比较低。当然我不确定这样是不是解决问题的最佳方法，但却引出了另一个问题：比较函数的两个参数是同类型的容器，除了支持std::multiset，也可以接收其他容器比如std::set（题目可以改成忽略数列中的重复数字），那么自然想到可以使用模版，当传入的是vector或list时，由于这类容器不一定已排序序，函数判断的结果无效，另外就是容器只允许包含算术类型以方便比较，否则最好在编译阶段就报错，这样可以保证函数被正确使用，让可能的错误提前曝光。那么，该如何限制下面这个函数模版被具体化时所使用的类型呢？

template <class Container>
bool equal(const Container &container1, const Container &container2)
{
    if (container1.size() != container2.size())
    {
        return false;
    }
    for (Container::const_iterator it1 = container1.begin(), it2 = container2.begin();
         it1 != container1.end() && it1 != container1.end();
         ++it1, ++it2)
    {
        if (*it1 != *it2)
        {
            return false;
        }
    }
    return true;
}

由于是在编译阶段进行判断，那么免不了模版相关的编程，我对泛型编程的了解有限，还好万能的互联网可以帮助到，于是把搜集到的方法整理了一下。与类型萃取相关的编程需要包含<type_traits>头文件。

template <typename>
struct is_set_or_multiset : std::false_type {};

template <typename... Args>
struct is_set_or_multiset<std::set<Args ...>> : std::true_type {};

template <typename... Args>
struct is_set_or_multiset<std::multiset<Args ...>> : std::true_type {};

template <class Container,
          class = typename std::enable_if_t<std::is_arithmetic<typename Container::value_type>::value
                                            && is_set_or_multiset<Container>::value>>
bool equal1(const Container &container1, const Container &container2)
{
    ...
}

这种方法比较容易想到，属于最自然而然的模式匹配。

template <template <class ...> class U, class T>
struct is_instance_of_template : std::false_type {};

template <template <class ...> class U, class... Args>
struct is_instance_of_template<U, U<Args ...>> : std::true_type {};

template <class Container,
          class = typename std::enable_if_t<std::is_arithmetic<typename Container::value_type>::value
                                            && (is_instance_of_template<std::set, Container>::value
                                             || is_instance_of_template<std::multiset, Container>::value)>>
bool equal2(const Container &container1, const Container &container2)
{
    ...
}

该方法先判断是不是一个模版类，再进一步判断是不是我们想要的容器。相比而言我更喜欢前面那种方法，支持新的类型只需添加一个类，而不用修改函数模版。

template <class Container,
          class = typename std::enable_if_t<std::is_arithmetic<typename Container::value_type>::value
                                            && (std::is_same<std::remove_reference<Container>::type, std::set<typename Container::value_type>>::value
                                             || std::is_same<std::remove_reference<Container>::type, std::multiset<typename Container::value_type>>::value)>>
bool equal3(const Container &container1, const Container &container2)
{
    ...
}

这种方法比较直观，和上面那种方式一样都是在函数模版上面进行条件判断，用到了type_traits里的std::is_same，个人更倾向于使用标准库的方法。

template <typename Container,
          typename = typename std::enable_if<std::is_arithmetic<Container::key_type>::value
                                             && std::is_arithmetic<Container::value_type>::value>::type>
bool equal4(const Container& container1, const Container& container2)
{
    return true;
}

最后还有一种偏门的方法，其实是利用了set和multiset的一个特殊之处，在标准STL容器里面只有这两种容器既有key_type又有value_type且表示同一个数值，如果我们故意定制一种容器，是可以破坏这个判断的，所以这种方法不推荐使用。最后给出测试代码：

int main(void)
{
    std::set<int> s1;
    std::set<int> s2;
    equal(s1, s2);    //  OK

    std::multiset<float> s3;
    std::multiset<float> s4;
    equal(s3, s4);    //  OK

    typedef std::multiset<double> MULTISET;
    MULTISET s5;
    MULTISET s6;
    equal(s5, s6);    //  OK

    std::set<int> s1_;
    std::multiset<int> s2_;
    //equal(s1_, s2_);    //  compile error

    std::set<int*> s3_;
    std::set<int*> s4_;
    //equal(s3_, s4_);    //  compile error

    std::vector<int> s5_;
    std::vector<int> s6_;
    //equal(s5_, s6_);    //  compile error

    std::map<int, int> s7_;
    std::map<int, int> s8_;
    //equal(s7_, s8_);    //  compile error

    return 0;
}

这个话题还可以进一步延伸，比如可以让函数模版支持任何容器包括自定义容器，只要这个容器有size方法，可以被sort，能用标准迭代器顺序遍历，且包含的元素不仅仅只允许内置的算术类型，即便是个类，只要重载了less方法可用于比较，那么都该接受。用类型萃取完全是可以实现的，就是写起来又臭又长，还会损伤脑细胞。谁叫C++的模版用丑陋的语法包裹着函数式编程的思维呢。