标准库容器的通用函数模板
Generalised function template for standard library containers
我正在尝试编写一个简单的通用函数来迭代容器元素。每个元素都转换为std::string
(无论如何)并存储在另一个地方。基本版本很简单:
template<class Container>
void ContainerWork(const Container& c)
{
for(const auto& elem : c) {
/* convert to string and store*/
}
}
然后,有必要为值类型为 std::string
且代码转换为的容器添加专用化:
template<typename T, template<typename, typename> class Container, class Allocator>
void ContainerWork(Container<T, Allocator> c)
{
for(const T& elem : c) {
/* convert to string and store*/
}
}
template<template<typename, typename> class Container, class Allocator>
void ContainerWork(Container<std::string, Allocator> c)
{
for(const std::string& elem : c) {
/* frame elem in quotes*/
}
}
它工作得很好,但现在我只能使用排序容器(vector
、list
等),但我也想使用 set
和 unordered_set
.任何想法如何在没有"复制粘贴"实现的情况下为具有 4 个参数的容器做到这一点?我试图和decltype(Container)::value_type
一起玩,但没有运气。
我可能会使用大多数 c++11 功能(编译器 - VS2012 或 GCC 4.8.x)
这就是为什么所有标准库的算法都适用于迭代器而不是容器。
您可以更改核心函数以处理迭代器而不是容器。这将需要部分专用化,而函数模板不存在这种专用化,因此我们将使用委托到类技巧:
template <typename It>
void DoIteratorWork(It start, It end)
{
DoIteratorWork_Impl<It, typename std::iterator_traits<It>::value_type>::call(start, end);
}
template <typename It, typename ValueType>
struct DoIteratorWork_Impl
{
static void call(It start, It end)
{
for (; start != end; ++start) {
// operate on *it
}
}
};
template <typename It>
struct DoIteratorWork_Impl<It, std::string>
{
static void call(It start, It end)
{
for (; start != end; ++start) {
// operate on *it
}
}
};
如果你真的愿意,你可以围绕这个创建一个包装器:
template <class Container>
void DoContainerWork(const Container& c)
{
using std::begin; using std::end; // enable ADL of begin and end
return DoIteratorWork(begin(c), end(c));
}
variadic-templates
,类似
template<typename T, template<typename...> class Container, typename... Args>
void ContainerWork(Container<T, Args...> c)
{
}
template<template<typename...> class Container, typename... Args>
void ContainerWork(Container<std::string, Args...> c)
{
}
也许你当然可以使用简单的调度
template<typename Container>
void ContainerWork(Container c,
typename std::enable_if<!std::is_same<typename Container::value_type,
std::string>::value>::type* = 0)
{
}
template<typename Container>
void ContainerWork(Container c,
typename std::enable_if<std::is_same<typename Container::value_type,
std::string>::value>::type* = 0)
{
}
但无论如何,如果差异仅在于调用转换函数 - 您可以简单地重载它以进行T
和string
,string
的版本将简单地返回此字符串。
您也可以将SFINAE
与 C++11 decltype
功能一起使用
template<typename Container>
auto ContainerWork(Container c) ->
decltype(c.begin(),
typename std::enable_if<!std::is_same<typename Container::value_type,
std::string>::value, void>::type())
{
}
template<typename Container>
auto ContainerWork(Container c) ->
decltype(c.begin(),
typename std::enable_if<std::is_same<typename Container::value_type,
std::string>::value, void>::type())
{
}
// implement the bodies as functors to allow for partial
// specialization for value_type:
template <class value_type>
struct DoContainerWorkImpl {
template<typename Container>
void operator()(const Container& c) const
{
for (auto&& x : c) {
// code
}
}
};
template <>
struct DoContainerWorkImpl<std::string> {
template<typename Container>
void operator()(const Container& c) const
{
for (std::string const& x : c) {
// code
}
}
};
template <class Container>
void DoContainerWork(const Container& c)
{
using std::begin; // enable ADL of begin
// extract the iterator for the container c:
typedef typename std::decay<decltype( std::begin(c) )>::type iterator;
// extract the value type of the container:
typedef typename std::iterator_traits<iterator>::value_type value_type;
DoContainerWorkImpl<value_type>()( c );
}
另一种方法是使算法成为一件事,并确定我们是否要使用 traits 类或其他技术"本地"调用算法主体内的转换。
以下是对这种方法的尝试:
// convert non-strings:
template<typename T>
std::string as_string( T&& t )
{
// converting code goes here
}
// block dangling rvalues:
std::string as_string( std::string&& s ) { return std::move(s); }
// pass lvalues through:
std::string const& as_string( std::string const& s ) { return s; }
std::string const& as_string( std::string& s ) { return s; }
现在,我们在您的循环体中执行此操作:
for(auto&& elem : c) {
std::string const& s = as_string(std::forward<decltype(elem)>(elem));
// code using s as a string
}
如果容器是 std::string
的容器,则编译为 noop(或最坏的情况是几步),如果不是,则编译为转换代码。
分配给引用的临时文件的生存期延长使任何临时生成的std::string
保持存在,迭代器的左值生存期使"其迭代器返回引用的字符串容器"的生存期保持足够长的时间。
据我了解,您可以将std::for_each
与多态函子一起使用:
namespace detail {
template<typename T>
std::string do_conversion(const T& item) {
// convert to string
}
template<>
std::string do_conversion<std::string>(const std::string& item) {
// frame in quotes
}
}
struct convert_to_string {
template<typename T>
void operator()(const T& item) {
// delegate to free function in namespace scope, because otherwise we
// cannot specialize
std::string result = detail::do_conversion(item);
}
};
// in calling code
std::for_each(std::begin(container), std::end(container), convert_to_string{});
这对你有用吗?
- 当函数模板参数是具有默认参数的类模板时,函数模板参数的推导如何执行
- 将重载的成员函数传递给函数模板
- C++17中函数模板中的静态数组初始化(MSVC 2019)
- 编译器如何在使用SFINAE的函数和标准函数之间确定两者是否可行
- 为什么 gcc 和 clang 为函数模板的实例化生成不同的符号名称?
- 具有常量引用参数的函数模板专用化
- std::span<const T> 作为函数模板中的参数
- 如何编写一个完美的缩写函数模板?
- 仅在函数模板中为那些定义了函数的类型执行函数
- 如何在C++中伪造虚拟可变参数函数模板?
- 以下代码中的函数模板有什么问题?
- 在 C++20 中是否不再允许在 std 中对程序定义类型的函数模板进行专用化?
- 将显式实例化的函数模板与转换匹配
- 使用定义函数模板别名
- 'Incomplete type' 为标准::函数声明指向成员的指针函数模板参数时出错
- 标准库容器的通用函数模板
- 为什么c++标准不允许函数模板部分特化
- 标准说,我们可以定义静态数据成员模板,比如类模板和函数模板,但具体如何定义
- 接收任何标准映射的函数模板
- 为什么标准容器使用函数模板而不是非模板Koenig操作符