接受 stl_container_type<string>::iterator 的模板化参数

Question

我有一个函数，其中我有一个包含字符串的容器（例如vector<string>、set<string>、list<string>），并且给定一个开始迭代器和一个结束迭代器，遍历处理字符串的迭代器范围。

目前函数是这样声明的：

template< typename ContainerIter>
void ProcessStrings(ContainerIter begin, ContainerIter end);

现在这将接受任何符合实现 operator* 的隐式接口、前缀 operator++ 以及函数体中的任何其他调用的任何类型。

我真正想做的是有一个像下面这样明确限制输入量的定义（伪代码警告）：

template< typename Container<string>::iterator>
void ProcessStrings(Container<string>::iterator begin, Container<string>::iterator end);

这样我就可以这样使用它：

vector<string> str_vec;
list<string> str_list;
set<SomeOtherClass> so_set;

ProcessStrings(str_vec.begin(), str_vec.end());  // OK
ProcessStrings(str_list.begin(), str_list.end());  //OK
ProcessStrings(so_set.begin(), so_set.end());  // Error

本质上，我要做的是限制函数规范，使函数的用户清楚它接受的内容，如果代码编译失败，他们会收到一条消息，表明他们使用了错误的参数类型，而不是在函数体中找不到 XXX 类的 XXX 函数。

Answer 1

您可以使用boost::enable_if 模板魔法来实现此类检查。除非迭代器的值类型是字符串类型，否则下面的方法不会被编译。

template<class It>
boost::enable_if_c< 
        boost::is_same< typename boost::iterator_value<It>::type, string >::value
>::type
ProcessStrings(It itBegin, It itEnd) 
{ }

如果boost::iterator_value<It>::type 是字符串类型，boost::enable_if<...>::type 将评估为 void，即您的返回参数。否则，由于 SFINAE（substitution-failure is not an error）原则，该方法将不会在没有错误的情况下编译。

Answer 2

一个简单但有效的方法。

template <class T>
struct is_basic_string: boost::mpl::false_ {};

template <class CharT, class Traits, class Alloc>
struct is_basic_string< std::basic_string<CharT, Traits, Alloc> >:
   boost::mpl::true_ {};

然后用它来检查值类型

void ProcessStrings(Iterator begin, Iterator end)
{
  BOOST_MPL_ASSERT_MSG(
    is_basic_string< typename boost::value_type<Iterator>::type >,
    ONLY_ACCEPT_ITERATOR_TO_BASIC_STRING,
    (Iterator)
  );

  // do your work
}

查看参考here，此宏旨在在编译时提供尽可能有意义的消息。

这也比Sebastian 解决方案更通用...但std::wstring 对国际化非常方便，你不会想窒息的。

现在很好的问题是……你为什么要这样做！

泛型编程的真正目标是生成可以与任何符合它们内部使用的操作的类型一起工作的函数。为什么要故意限制这一点？

Answer 3

试试

#include <string>
#include <vector>
#include <list>

template<template<typename T,typename A> class C>
void ProcessStrings(typename C<std::string, std::allocator<std::string> >::iterator begin,
                    typename C<std::string, std::allocator<std::string> >::iterator end)
{
}


int main()
{
    std::vector<std::string>    strVec;
    std::list<std::string>      strList;
    std::list<int>              intList;

    ProcessStrings<std::vector>(strVec.begin(), strVec.end());
    ProcessStrings<std::list>(strList.begin(), strList.end());
    ProcessStrings<std::list>(intList.begin(), intList.end());  // This will fail
}

Answer 4

您可以使用模板模板参数来接近这一点：

template<template<class> class CONTAINER>
void ProcessStrings(CONTAINER<string>&);

这将处理整个容器，如果它不包含字符串，则会出现编译错误。

ProcessStrings(str_vec); // OK
ProcessStrings(so_set); // Error

如果你想使用迭代器范围，那么我能管理的最好的就是

template<template<class> class CONTAINER>
void ProcessStrings(typename CONTAINER<string>::iterator, 
                    typename CONTAINER<string>::iterator);

不幸的是，类型推断不适用于函数参数，因此您必须显式提供模板参数：

ProcessStrings<vector>(str_vec.begin(), str_vec.end()); // OK
ProcessStrings<set>(so_set.begin(), so_set.end()); // Error

有人可以改进吗？