所以这里有一大堆角落案例需要处理。我要做的是首先尝试构建一些container_traits模板来尽可能多地抽象工作。
一个类型是 acontainer如果它允许调用 和 已经通过 发挥作用的begin自由函数end，std::begin并且这两种类型是相同的（最后可能不是必需的）。std::endusing
a 的特征container主要来自iterator容器具有的 s 以及所述迭代器的类型。其他一些功能，比如size（甚至size_at_least——见下文），是很常见的。
iterable如果类型的 是 a ，则称const该类型为container。
下一个问题是“什么样的类型实例对于映射容器的元素是有效的？” -- 这也有点不重要，所以我添加了一些特征类来处理它。
所以，这导致了这个实现：
#include <algorithm>
#include <type_traits>
#include <utility>
namespace aux {
// calculate the type that calling `begin` and `end` on a type will return
// in a scope where `std::begin` and `std::end` are visible. This hack is
// required to enable argument-dependent lookup.
using std::begin;
using std::end;
template<typename T>
auto adl_begin(T&&t)->decltype( begin(std::forward<T>(t)) );
template<typename T>
auto adl_end(T&&t)->decltype( end(std::forward<T>(t)) );
template<typename T>
auto adl_cbegin(T const&t)->decltype( begin(t) );
template<typename T>
auto adl_cend(T const&t)->decltype( end(t) );
}
// What is a container? Something with a `begin`ing and an `end`ing...
template<typename C,typename=void>
struct is_container:std::false_type {};
template<typename C>
struct is_container<C, typename std::enable_if<
std::is_same<
decltype(aux::adl_begin(std::declval<C>())),
decltype(aux::adl_end(std::declval<C>()))
>::value
>::type >:std::true_type {};
// Default container_traits is empty for SFINAE ease of use:
template<typename C, typename=void>
struct container_traits {};
// if it is a container, go in whole hog:
template<typename C>
struct container_traits<C, typename std::enable_if< is_container<C>::value >::type >
{
typedef decltype( aux::adl_begin(std::declval<C>()) ) iterator;
typedef decltype( aux::adl_cbegin(std::declval<C>()) ) const_iterator;
// I'm lazy, so I'll copy typedefs from `iterator_traits` below:
typedef typename std::iterator_traits<iterator>::value_type value_type;
typedef typename std::iterator_traits<iterator>::reference reference;
// etc
// TODO: size_at_least is a helper function
// it returns 0 if it is expensive to calculate the size (say, a range
// if iterators into a `std::list`), and the size if it is cheap to
// calculate (say, a `std::vector`, any class with a `.size()` method,
// or a pair of pointers or other random-access iterators)
// template<typename C2, typename=typename std::enable_if< std::is_convertable< C2, C const&>::value>::type
// static std::size_t size_at_least( C2&& c ) { ... }
};
// Can Functor map the elements of C into something we can store elsewhere?
template<typename C, typename Functor, typename=void>
struct can_map:std::false_type {};
// Yes, if the result of calling Functor on C's elements is non-void:
template<typename C, typename Functor>
struct can_map<C, Functor, typename std::enable_if<
!std::is_same< decltype(std::declval<Functor>()(std::declval<typename container_traits<C>::value_type>())), void >::value
>::type>: std::true_type {};
// The result of mapping the elements of C under Functor
template<typename C, typename Functor, typename=void>
struct map_result {};
template<typename C, typename Functor>
struct map_result<C,Functor,typename std::enable_if< can_map<C,Functor>::value>::type>
{
typedef
decltype(
std::declval<Functor>()(
*std::declval<
typename container_traits<C>::const_iterator
>()
)
)
type;
};
// The actual implementation
// we std::decay the map_result because we want to store
// instances of the type, and std::decay does that quite nicely
// note that some pathological Functors may break this, ie ones
// that return pseudo-references that are intended to be read from
// yet are not std-container safe
template <typename T, typename Func>
auto map_container(T&& iterable, Func&& func) ->
std::vector<
typename std::decay<
typename map_result<T, Func>::type
>::type
>
{
std::vector<
typename std::decay<
typename map_result<T, Func>::type
>::type
> retval;
// TODO: use container_traits<T>::size_at_least to reserve space in retval
// that will bring the efficiency of this function up to near-hand-crafted-C.
for (auto&& s:iterable) {
retval.push_back( func(s) );
}
return retval;
}
就是这样。接下来，测试代码。我们应该能够通过方法和自由浮动函数map_container处理 C 风格vector的数组，传统类型和bool（使用伪引用并紧密打包位）和用户定义类型。.begin()begin(C)
我对数组的一个问题是，它C const&似乎会导致数组中的指针衰减，这使得它不再是一个容器：我必须绑定到C&&才能获得真正的数组类型。
#include <iostream>
void test1() {
std::vector<int> src{1,2,3,4,5};
auto r = map_container( src, [](int x){return x*2;});
for (auto&& x:r) {
std::cout << x << "\n";
}
}
struct test_buffer {
int foo[5];
int* begin() { return foo; }
int* end() { return &foo[5]; }
int const* begin() const { return foo; }
int const* end() const { return &foo[5]; }
};
test_buffer buff1={{1,2,3,4,5}};
struct test_buffer_2 {
int foo[5];
};
test_buffer_2 buff2={{1,2,3,4,5}};
int* begin(test_buffer_2& t) { return t.foo; }
int* end(test_buffer_2& t) { return &t.foo[5]; }
int const* begin(test_buffer_2 const& t) { return t.foo; }
int const* end(test_buffer_2 const& t) { return &t.foo[5]; }
std::vector<bool> bits{true, false, true, false};
template<typename Container>
void tester(Container&& c) {
Container const& src = c;
auto r = map_container( src, [](int x){return x*2;});
for (auto&& x:r) {
std::cout << x << "\n";
}
}
void test2() {
tester(buff1);
tester(buff2);
tester(bits);
}
template<typename C>
bool is_container_test(C&&) {
return is_container<C>::value;
}
template<typename C, typename F>
bool can_map_test( C&&, F&& ) {
return can_map<C, F>::value;
}
template<typename C, typename F>
bool can_map_test2( C const&, F&& ) {
return can_map<C, F>::value;
}
int array[] = {1,2,3,4,5};
void test3() {
std::cout << "Array is container:" << is_container_test(array) << "\n";
auto x2 = [](int x){return x*2;};
std::cout << "Double can map:" << can_map_test(array, x2) << "\n";
std::cout << "Double can map:" << can_map_test2(array, x2) << "\n";
}
void test4() {
tester(array);
}
int main() {
test1();
test2();
test3();
test4();
}
或类似的规定。不要在函数本身中执行复杂的 SFINAE，而是创建为您完成工作的特征类。
上面使用的其他技术：我使用std::beginandstd::end来获取开始/结束迭代器。这意味着我现在支持原始 C 数组。然后我将它包装在一些依赖于参数的查找助手中，其目的是允许您在同一个命名空间中定义begin和使用您的类覆盖。end
请注意，“不接受”版本container_traits是一个空结构，而不是未定义的结构。这让我们可以container_traits在其他地方使用 SFINAE。
哦，提高效率的方法是编写“智能保留”，它采用一个带有reserve方法的容器和一个您希望复制其大小的容器。如果您要复制的容器缺少随机访问迭代器并且缺少.size()方法，则它什么也不做，但如果有，它会执行.reserve( end(...)-begin(...) )or .reserve(src.size())。container_traits我们可以通过将它添加到as来为其他算法抽象它static size_t size_at_least(Container const&)，它在 O(1) 时间内返回size_t不大于 的大小Container。