How do you avoid code duplication when using varadic parameters in c++? Notice that I'm using templates recursively to achieve my goals, therefore I need some base cases and a recursive case. This creates a lot of code duplication, are there ways I could reduce this duplication?
Below, an example is provided of code that creates an arbitrary tensor (N dimensional array).
It's working fine but there's too much duplication. How can I avoid writing duplicated code when using template parameter packs recursively like this?
#include <cstddef>
#include <array>
#include <iostream>
template<typename T, std::size_t...>
class Tensor;
template<typename T, std::size_t N>
class Tensor<T, N> {
using Type = std::array<T, N>;
Type data;
public:
Tensor()
{
zero();
}
void zero()
{
fill(0);
}
Type::iterator begin() { return data.begin(); }
Type::iterator end() { return data.end(); }
void fill(T value)
{
std::fill(data.begin(), data.end(), value);
}
void print() const
{
std::cout << "[";
for(const auto& v : data)
{
std::cout << v << ",";
}
std::cout << "]";
}
};
template<typename T, std::size_t N, std::size_t M>
class Tensor<T, N, M>
{
using Type = std::array<Tensor<T, M>, N>;
Type data;
public:
Tensor()
{
zero();
}
void zero()
{
fill(0);
}
Type::iterator begin() { return data.begin(); }
Type::iterator end() { return data.end(); }
void fill(T value)
{
for(auto& v: data) {
std::fill(v.begin(), v.end(), value);
}
}
void print() const
{
std::cout << "[";
for(const auto& v : data)
{
v.print();
std::cout << ",";
}
std::cout << "]";
}
};
template<typename T, std::size_t N, std::size_t... M>
class Tensor<T, N, M...>
{
using Type = std::array<Tensor<T, M...>, N>;
Type data;
public:
Type::iterator begin() { return data.begin(); }
Type::iterator end() { return data.end(); }
Tensor()
{
zero();
}
void zero()
{
fill(0);
}
void fill(T value)
{
for(auto& v: data) {
v.fill(value);
}
}
void print() const
{
std::cout << "[";
for(const auto& v : data)
{
v.print();
std::cout << ",";
}
std::cout << "]";
}
};
The only difference between a single-dimension tensor and a multiple-dimension tensor is the type of std::array, T for single and Tensor<T, M...> for another.
template<typename T, std::size_t N, std::size_t... M>
class Tensor<T, N, M...> {
using InnerT = std::conditional_t<(sizeof...(M) > 0),
Tensor<T, M...>,
T>;
using Type = std::array<InnerT, N>;
Type data;
}
Then, use if constexpr to distinguish single-dimension case,
void fill(T value)
{
if constexpr(sizeof...(M) > 0) {
for(auto& v: data) {
v.fill(value);
}
} else {
std::fill(data.begin(), data.end(), value);
}
}
void print() const
{
std::cout << "[";
for(const auto& v : data)
{
if constexpr(sizeof...(M) > 0) {
v.print();
std::cout << ",";
} else {
std::cout << v << ",";
}
}
std::cout << "]";
}
Demo
I tried two methods to implement conversion from a const_iterator to an iterator. All iterators are based on boost/iterator.
Method 1 defines a iterator<T> class. iterator<const T> would represent a const_iterator. iterator<T> has a conversion operator that returns a iterator<const T>. This fails for template function because no type conversion can happen during template instantiation.
Method 2 works in theory. In practice, I need to define every method for the iterator<T>:
#include <iostream>
#include <boost/iterator/iterator_adaptor.hpp>
#include <vector>
template<typename Container>
class Cit
: public boost::iterator_adaptor<
Cit<Container>, // Derived
typename Container::const_iterator, // Base
const typename Container::value_type> {
using self_type = Cit<Container>;
friend class boost::iterator_core_access;
public:
explicit Cit(typename Container::const_iterator it)
: self_type::iterator_adaptor_(it) {}
};
template<typename Container>
class It : public Cit<Container> {
protected:
using reference = typename Container::reference;
using self_type = It<Container>;
using Base = Cit<Container>;
public:
explicit It(typename Container::iterator it)
: Base(it) {}
reference operator*() const {
return const_cast<reference>(Base::operator*());
}
// Try to hide every method from Cit<Container>
// ...
// ...
// ...
// ... oh well.
private:
friend class boost::iterator_core_access;
};
// A template function
template<typename Container>
void foo(Cit<Container> it_begin,
Cit<Container> it_end) {
for (auto it = it_begin; it != it_end; ++it) {
std::cout << *it << "\n";
}
}
int main() {
typedef std::vector<int> Container;
Container v = {0, 1, 2, 3}; // content array
It<Container> it_begin(v.begin());
It<Container> it_end(v.end());
// Assert It can implicitly convert to Cit even during template
// instantiation.
foo(it_begin, it_end);
return 0;
}
This seems to negate the benefits of using boost/iterator.
Is there a better way to make iterator and const_iterator with
boost/iterator?
Here is method 1:
#include <iostream>
#include <boost/iterator/iterator_adaptor.hpp>
#include <vector>
template<typename Container>
class It
: public boost::iterator_adaptor<
It<Container>, // Derived
typename Container::const_iterator, // Base
typename std::conditional<std::is_const<Container>::value,
const typename Container::value_type,
typename Container::value_type
>::type // Value
> {
using self_type = It<Container>;
friend class boost::iterator_core_access;
public:
explicit It(typename Container::const_iterator it)
: self_type::iterator_adaptor_(it) {}
};
template <typename C> using Cit = It<const C>;
// A template function
template<typename Container>
void foo(Cit<Container> it_begin,
Cit<Container> it_end) {
for (auto it = it_begin; it != it_end; ++it) {
std::cout << *it << "\n";
}
}
int main() {
typedef std::vector<int> Container;
Container v = {0, 1, 2, 3}; // content array
It<Container> it_begin(v.begin());
It<Container> it_end(v.end());
// Assert It can implicitly convert to from Cit to It even
// during template instantiation.
foo(it_begin, it_end);
return 0;
}
Error message:
error: no matching function for call to ‘foo(It<std::vector<int> >&, It<std::vector<int> >&)’
foo(it_begin, it_end);
^
main.cpp:26:6: note: candidate: template<class Container> void foo(Cit<Container>, Cit<Container>)
void foo(Cit<Container> it_begin,
^~~
main.cpp:26:6: note: template argument deduction/substitution failed:
main.cpp:41:25: note: types ‘const C’ and ‘std::vector<int>’ have incompatible cv-qualifiers
foo(it_begin, it_end);
I would specialize the template:
template <typename T>
class MyIt : public boost::iterator_adaptor<MyIt<T>, // Derived
typename T::iterator, // Base
typename T::reference> {
friend class boost::iterator_core_access;
public:
static constexpr bool is_const = false;
explicit MyIt(typename MyIt::base_type it) : MyIt::iterator_adaptor_(it) {}
};
template <typename T>
class MyIt<T const> : public boost::iterator_adaptor<MyIt<T const>, // Derived
typename T::const_iterator, // Base
typename T::const_reference> {
friend class boost::iterator_core_access;
public:
static constexpr bool is_const = true;
explicit MyIt(typename MyIt::base_type it) : MyIt::iterator_adaptor_(it) {}
};
Conversions are already allowed here, but if you want to have an explicit "to-const-cast" it's easy to write:
template <typename T>
static MyIt<T const> make_const(MyIt<T> it) { return MyIt<T const>(it.base()); }
Use it:
// A template function
template <typename It> void foo(It it_begin, It it_end) {
static_assert(It::is_const == std::is_const<typename std::remove_reference<decltype(*it_begin)>::type>::value, "mismatch");
if (It::is_const)
std::cout << "Const: ";
for (auto it = it_begin; it != it_end; ++it)
std::cout << *it << " ";
std::cout << "\n";
}
As you can see our function doesn't care about the specific iterator (this is the whole point of iterators). You can use it with const and non-const:
template <typename C> void foo(C const &c) {
MyIt<C const> b(c.begin()), e(c.end());
foo(b, e);
}
template <typename C> void foo(C &c) {
MyIt<C> b(c.begin()), e(c.end());
foo(b, e);
}
Quick Demo Live On Coliru
std::vector<int> v{ 0, 1, 2, 3 };
foo(v);
auto const &constv = v;
foo(constv);
Prints
void foo(C&) [with C = std::vector<int>]
0 1 2 3
void foo(const C&) [with C = std::vector<int>]
Const: 0 1 2 3
Forcing Const Iterators
This seems to be what your code is about. So, let's force that! It's a simple change of MyIt<C> to MyIt<C const>:
template <typename C> void foo(C &c) {
MyIt<C const> b(c.begin()), e(c.end()); // <--- note the const
foo(b, e);
}
Now foo will be called using const iterators even for non-const C. If you think that's subtle, you can use the helper shown above:
template <typename C> void foo(C &c) {
MyIt<C> b(c.begin()), e(c.end());
foo(make_const(b), make_const(e)); // <--- now more explicit?
}
Of course in foo you're free to modify the static_assert so that it just refuses to compile for non-const iterators in the first place:
// A template function
template <typename It> void foo(It it_begin, It it_end) {
static_assert(std::is_const<typename std::remove_reference<decltype(*it_begin)>::type>::value, "non-const disallowed");
if (It::is_const)
std::cout << "Const: ";
for (auto it = it_begin; it != it_end; ++it)
std::cout << *it << " ";
std::cout << "\n";
}
You can add an overload for any MyIt<> that does the constification:
template <typename C>
typename std::enable_if<!std::is_const<C>::value>::type
foo(MyIt<C> b, MyIt<C> e) {
foo(make_const(b), make_const(e));
}
So, now every invocation of foo is forced to const mode.
Full Listing
The last demo in full:
Live On Coliru
#include <boost/iterator/iterator_adaptor.hpp>
#include <iostream>
#include <vector>
template <typename T>
class MyIt : public boost::iterator_adaptor<MyIt<T>, // Derived
typename T::iterator, // Base
typename T::reference> {
friend class boost::iterator_core_access;
public:
static constexpr bool is_const = false;
explicit MyIt(typename MyIt::base_type it) : MyIt::iterator_adaptor_(it) {}
};
template <typename T>
class MyIt<T const> : public boost::iterator_adaptor<MyIt<T const>, // Derived
typename T::const_iterator, // Base
typename T::const_reference> {
friend class boost::iterator_core_access;
public:
static constexpr bool is_const = true;
explicit MyIt(typename MyIt::base_type it) : MyIt::iterator_adaptor_(it) {}
};
template <typename T>
static MyIt<T const> make_const(MyIt<T> it) { return MyIt<T const>(it.base()); }
// A template function
template <typename It> void foo(It it_begin, It it_end) {
static_assert(std::is_const<typename std::remove_reference<decltype(*it_begin)>::type>::value, "non-const disallowed");
if (It::is_const)
std::cout << "Const: ";
for (auto it = it_begin; it != it_end; ++it)
std::cout << *it << " ";
std::cout << "\n";
}
template <typename C>
typename std::enable_if<!std::is_const<C>::value>::type
foo(MyIt<C> b, MyIt<C> e) {
foo(make_const(b), make_const(e));
}
template <typename C> void foo(C &c) {
std::cout << __PRETTY_FUNCTION__ << "\n";
MyIt<C> b(c.begin()), e(c.end());
foo(b, e);
}
int main() {
std::vector<int> v{ 0, 1, 2, 3 };
foo(v);
auto const &constv = v;
foo(constv);
}
Which now prints:
void foo(C&) [with C = std::vector<int>]
Const: 0 1 2 3
void foo(C&) [with C = const std::vector<int>]
Const: 0 1 2 3
With the new range-based for-loop we can write code like:
for(auto x: Y) {}
Which IMO is a huge improvement from (for ex.)
for(std::vector<int>::iterator x=Y.begin(); x!=Y.end(); ++x) {}
Can it be used to loop over two simultaneous loops, like Python's zip function? For those unfamiliar with Python, the code:
Y1 = [1, 2, 3]
Y2 = [4, 5, 6, 7]
for x1,x2 in zip(Y1, Y2):
print(x1, x2)
Gives as output (1,4) (2,5) (3,6)
Warning: boost::zip_iterator and boost::combine as of Boost 1.63.0 (2016 Dec 26) will cause undefined behavior if the length of the input containers are not the same (it may crash or iterate beyond the end).
Starting from Boost 1.56.0 (2014 Aug 7) you could use boost::combine (the function exists in earlier versions but undocumented):
#include <boost/range/combine.hpp>
#include <vector>
#include <list>
#include <string>
int main() {
std::vector<int> a {4, 5, 6};
double b[] = {7, 8, 9};
std::list<std::string> c {"a", "b", "c"};
for (auto tup : boost::combine(a, b, c, a)) { // <---
int x, w;
double y;
std::string z;
boost::tie(x, y, z, w) = tup;
printf("%d %g %s %d\n", x, y, z.c_str(), w);
}
}
This would print
4 7 a 4
5 8 b 5
6 9 c 6
In earlier versions, you could define a range yourself like this:
#include <boost/iterator/zip_iterator.hpp>
#include <boost/range.hpp>
template <typename... T>
auto zip(T&&... containers) -> boost::iterator_range<boost::zip_iterator<decltype(boost::make_tuple(std::begin(containers)...))>>
{
auto zip_begin = boost::make_zip_iterator(boost::make_tuple(std::begin(containers)...));
auto zip_end = boost::make_zip_iterator(boost::make_tuple(std::end(containers)...));
return boost::make_iterator_range(zip_begin, zip_end);
}
The usage is the same.
std::transform can do this trivially:
std::vector<int> a = {1,2,3,4,5};
std::vector<int> b = {1,2,3,4,5};
std::vector<int>c;
std::transform(a.begin(),a.end(), b.begin(),
std::back_inserter(c),
[](const auto& aa, const auto& bb)
{
return aa*bb;
});
for(auto cc:c)
std::cout<<cc<<std::endl;
If the second sequence is shorter, my implementation seems to be giving default initialized values.
So I wrote this zip before when I was bored, I decided to post it because it's different than the others in that it doesn't use boost and looks more like the c++ stdlib.
template <typename Iterator>
void advance_all (Iterator & iterator) {
++iterator;
}
template <typename Iterator, typename ... Iterators>
void advance_all (Iterator & iterator, Iterators& ... iterators) {
++iterator;
advance_all(iterators...);
}
template <typename Function, typename Iterator, typename ... Iterators>
Function zip (Function func, Iterator begin,
Iterator end,
Iterators ... iterators)
{
for(;begin != end; ++begin, advance_all(iterators...))
func(*begin, *(iterators)... );
//could also make this a tuple
return func;
}
Example use:
int main () {
std::vector<int> v1{1,2,3};
std::vector<int> v2{3,2,1};
std::vector<float> v3{1.2,2.4,9.0};
std::vector<float> v4{1.2,2.4,9.0};
zip (
[](int i,int j,float k,float l){
std::cout << i << " " << j << " " << k << " " << l << std::endl;
},
v1.begin(),v1.end(),v2.begin(),v3.begin(),v4.begin());
}
With range-v3:
#include <range/v3/all.hpp>
#include <vector>
#include <iostream>
namespace ranges {
template <class T, class U>
std::ostream& operator << (std::ostream& os, common_pair<T, U> const& p)
{
return os << '(' << p.first << ", " << p.second << ')';
}
}
using namespace ranges::v3;
int main()
{
std::vector<int> a {4, 5, 6};
double b[] = {7, 8, 9};
std::cout << view::zip(a, b) << std::endl;
}
The output:
[(4, 7),(5, 8),(6, 9)]
See <redi/zip.h> for a zip function which works with range-base for and accepts any number of ranges, which can be rvalues or lvalues and can be different lengths (iteration will stop at the end of the shortest range).
std::vector<int> vi{ 0, 2, 4 };
std::vector<std::string> vs{ "1", "3", "5", "7" };
for (auto i : redi::zip(vi, vs))
std::cout << i.get<0>() << ' ' << i.get<1>() << ' ';
Prints 0 1 2 3 4 5
You can use a solution based on boost::zip_iterator. Make a phony container class maintaining references to your containers, and which return zip_iterator from the begin and end member functions. Now you can write
for (auto p: zip(c1, c2)) { ... }
Example implementation (please test):
#include <iterator>
#include <boost/iterator/zip_iterator.hpp>
template <typename C1, typename C2>
class zip_container
{
C1* c1; C2* c2;
typedef boost::tuple<
decltype(std::begin(*c1)),
decltype(std::begin(*c2))
> tuple;
public:
zip_container(C1& c1, C2& c2) : c1(&c1), c2(&c2) {}
typedef boost::zip_iterator<tuple> iterator;
iterator begin() const
{
return iterator(std::begin(*c1), std::begin(*c2));
}
iterator end() const
{
return iterator(std::end(*c1), std::end(*c2));
}
};
template <typename C1, typename C2>
zip_container<C1, C2> zip(C1& c1, C2& c2)
{
return zip_container<C1, C2>(c1, c2);
}
I leave the variadic version as an excellent exercise to the reader.
If you like operator overloading, here are three possibilities. The first two are using std::pair<> and std::tuple<>, respectively, as iterators; the third extends this to range-based for. Note that not everyone will like these definitions of the operators, so it's best to keep them in a separate namespace and have a using namespace in the functions (not files!) where you'd like to use these.
#include <iostream>
#include <utility>
#include <vector>
#include <tuple>
// put these in namespaces so we don't pollute global
namespace pair_iterators
{
template<typename T1, typename T2>
std::pair<T1, T2> operator++(std::pair<T1, T2>& it)
{
++it.first;
++it.second;
return it;
}
}
namespace tuple_iterators
{
// you might want to make this generic (via param pack)
template<typename T1, typename T2, typename T3>
auto operator++(std::tuple<T1, T2, T3>& it)
{
++( std::get<0>( it ) );
++( std::get<1>( it ) );
++( std::get<2>( it ) );
return it;
}
template<typename T1, typename T2, typename T3>
auto operator*(const std::tuple<T1, T2, T3>& it)
{
return std::tie( *( std::get<0>( it ) ),
*( std::get<1>( it ) ),
*( std::get<2>( it ) ) );
}
// needed due to ADL-only lookup
template<typename... Args>
struct tuple_c
{
std::tuple<Args...> containers;
};
template<typename... Args>
auto tie_c( const Args&... args )
{
tuple_c<Args...> ret = { std::tie(args...) };
return ret;
}
template<typename T1, typename T2, typename T3>
auto begin( const tuple_c<T1, T2, T3>& c )
{
return std::make_tuple( std::get<0>( c.containers ).begin(),
std::get<1>( c.containers ).begin(),
std::get<2>( c.containers ).begin() );
}
template<typename T1, typename T2, typename T3>
auto end( const tuple_c<T1, T2, T3>& c )
{
return std::make_tuple( std::get<0>( c.containers ).end(),
std::get<1>( c.containers ).end(),
std::get<2>( c.containers ).end() );
}
// implement cbegin(), cend() as needed
}
int main()
{
using namespace pair_iterators;
using namespace tuple_iterators;
std::vector<double> ds = { 0.0, 0.1, 0.2 };
std::vector<int > is = { 1, 2, 3 };
std::vector<char > cs = { 'a', 'b', 'c' };
// classical, iterator-style using pairs
for( auto its = std::make_pair(ds.begin(), is.begin()),
end = std::make_pair(ds.end(), is.end() ); its != end; ++its )
{
std::cout << "1. " << *(its.first ) + *(its.second) << " " << std::endl;
}
// classical, iterator-style using tuples
for( auto its = std::make_tuple(ds.begin(), is.begin(), cs.begin()),
end = std::make_tuple(ds.end(), is.end(), cs.end() ); its != end; ++its )
{
std::cout << "2. " << *(std::get<0>(its)) + *(std::get<1>(its)) << " "
<< *(std::get<2>(its)) << " " << std::endl;
}
// range for using tuples
for( const auto& d_i_c : tie_c( ds, is, cs ) )
{
std::cout << "3. " << std::get<0>(d_i_c) + std::get<1>(d_i_c) << " "
<< std::get<2>(d_i_c) << " " << std::endl;
}
}
// declare a, b
BOOST_FOREACH(boost::tie(a, b), boost::combine(list_of_a, list_of_b)){
// your code here.
}
I ran into this same question independently and didn't like the syntax of any of the above. So, I have a short header file that essentially does the same as the boost zip_iterator but has a few macros to make the syntax more palatable to me:
https://github.com/cshelton/zipfor
For example you can do
vector<int> a {1,2,3};
array<string,3> b {"hello","there","coders"};
zipfor(i,s eachin a,b)
cout << i << " => " << s << endl;
The main syntactic sugar is that I can name the elements from each container. I also include a "mapfor" that does the same, but for maps (to name the ".first" and ".second" of the element).
If you have a C++14 compliant compiler (e.g. gcc5) you can use zip provided in the cppitertools library by Ryan Haining, which looks really promising:
array<int,4> i{{1,2,3,4}};
vector<float> f{1.2,1.4,12.3,4.5,9.9};
vector<string> s{"i","like","apples","alot","dude"};
array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
for (auto&& e : zip(i,f,s,d)) {
cout << std::get<0>(e) << ' '
<< std::get<1>(e) << ' '
<< std::get<2>(e) << ' '
<< std::get<3>(e) << '\n';
std::get<1>(e)=2.2f; // modifies the underlying 'f' array
}
For a C++ stream processing library I'm writing I was looking for a solution that doesn't rely on third party libraries and works with an arbitrary number of containers. I ended up with this solution. It's similar to the accepted solution which uses boost (and also results in undefined behavior if the container lengths are not equal)
#include <utility>
namespace impl {
template <typename Iter, typename... Iters>
class zip_iterator {
public:
using value_type = std::tuple<const typename Iter::value_type&,
const typename Iters::value_type&...>;
zip_iterator(const Iter &head, const Iters&... tail)
: head_(head), tail_(tail...) { }
value_type operator*() const {
return std::tuple_cat(std::tuple<const typename Iter::value_type&>(*head_), *tail_);
}
zip_iterator& operator++() {
++head_; ++tail_;
return *this;
}
bool operator==(const zip_iterator &rhs) const {
return head_ == rhs.head_ && tail_ == rhs.tail_;
}
bool operator!=(const zip_iterator &rhs) const {
return !(*this == rhs);
}
private:
Iter head_;
zip_iterator<Iters...> tail_;
};
template <typename Iter>
class zip_iterator<Iter> {
public:
using value_type = std::tuple<const typename Iter::value_type&>;
zip_iterator(const Iter &head) : head_(head) { }
value_type operator*() const {
return value_type(*head_);
}
zip_iterator& operator++() { ++head_; return *this; }
bool operator==(const zip_iterator &rhs) const { return head_ == rhs.head_; }
bool operator!=(const zip_iterator &rhs) const { return !(*this == rhs); }
private:
Iter head_;
};
} // namespace impl
template <typename Iter>
class seq {
public:
using iterator = Iter;
seq(const Iter &begin, const Iter &end) : begin_(begin), end_(end) { }
iterator begin() const { return begin_; }
iterator end() const { return end_; }
private:
Iter begin_, end_;
};
/* WARNING: Undefined behavior if iterator lengths are different.
*/
template <typename... Seqs>
seq<impl::zip_iterator<typename Seqs::iterator...>>
zip(const Seqs&... seqs) {
return seq<impl::zip_iterator<typename Seqs::iterator...>>(
impl::zip_iterator<typename Seqs::iterator...>(std::begin(seqs)...),
impl::zip_iterator<typename Seqs::iterator...>(std::end(seqs)...));
}
From C++23, we can iterate on std::views::zip.
Below is simple example.
#include <iostream>
#include <ranges>
#include <vector>
int main() {
std::vector<int> x {4, 5, 6};
double y[] = {7, 8, 9};
for (auto [elem1,elem2] : std::views::zip(x, y))
std::cout << "[" << elem1 << "," << elem2 << "]" << " ";
}
The output can be verified below (an online compiler). Not sure how many days the link exists.
https://godbolt.org/z/KjjE4eeGY
An improvement on aaronman's solution:
Still C++11.
No recursive template expansion.
Support for container zipping.
Utilizes the approach of Sean Parent's famed for_each_arg().
// Includes only required for the example main() below!
#include <vector>
#include <iostream>
namespace detail {
struct advance {
template <typename T> void operator()(T& t) const { ++t; }
};
// Adaptation of for_each_arg, see:
// https://isocpp.org/blog/2015/01/for-each-argument-sean-parent
template <class... Iterators>
void advance_all(Iterators&... iterators) {
[](...){}((advance{}(iterators), 0)...);
}
} // namespace detail
template <typename F, typename Iterator, typename ... ExtraIterators>
F for_each_zipped(
F func,
Iterator begin,
Iterator end,
ExtraIterators ... extra_iterators)
{
for(;begin != end; ++begin, detail::advance_all(extra_iterators...))
func(*begin, *(extra_iterators)... );
return func;
}
template <typename F, typename Container, typename... ExtraContainers>
F for_each_zipped_containers(
F func,
Container& container,
ExtraContainers& ... extra_containers)
{
return for_each_zipped(
func, std::begin(container), std::end(container), std::begin(extra_containers)...);
}
int main () {
std::vector<int> v1 { 1, 2, 3};
std::vector<int> v2 { 3, 2, 1};
std::vector<float> v3 {1.2, 2.4, 9.0};
std::vector<float> v4 {1.2, 2.4, 9.0};
auto print_quartet =
[](int i,int j,float k,float l) {
std::cout << i << " " << j << " " << k << " " << l << '\n';
};
std::cout << "Using zipped iterators:\n";
for_each_zipped(print_quartet, v1.begin(), v1.end(), v2.begin(), v3.begin(), v4.begin());
std::cout << "\nUsing zipped containers:\n";
for_each_zipped_containers(print_quartet, v1, v2, v3, v4);
}
See it working on GodBolt.
I would propose this one. I found it to be quite elegant, and exactly what I (and you) needed.
https://github.com/CommitThis/zip-iterator
Just in case here's a code copy. Note, it is distributed under MIT License, also don't forget to put name of author.
zip.hpp
/***
* MIT License
* Author: G Davey
*/
#pragma once
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <string>
#include <vector>
#include <typeinfo>
namespace c9 {
template <typename Iter>
using select_access_type_for = std::conditional_t<
std::is_same_v<Iter, std::vector<bool>::iterator> ||
std::is_same_v<Iter, std::vector<bool>::const_iterator>,
typename Iter::value_type,
typename Iter::reference
>;
template <typename ... Args, std::size_t ... Index>
auto any_match_impl(std::tuple<Args...> const & lhs,
std::tuple<Args...> const & rhs,
std::index_sequence<Index...>) -> bool
{
auto result = false;
result = (... | (std::get<Index>(lhs) == std::get<Index>(rhs)));
return result;
}
template <typename ... Args>
auto any_match(std::tuple<Args...> const & lhs, std::tuple<Args...> const & rhs)
-> bool
{
return any_match_impl(lhs, rhs, std::index_sequence_for<Args...>{});
}
template <typename ... Iters>
class zip_iterator
{
public:
using value_type = std::tuple<
select_access_type_for<Iters>...
>;
zip_iterator() = delete;
zip_iterator(Iters && ... iters)
: m_iters {std::forward<Iters>(iters)...}
{
}
auto operator++() -> zip_iterator&
{
std::apply([](auto && ... args){ ((args += 1), ...); }, m_iters);
return *this;
}
auto operator++(int) -> zip_iterator
{
auto tmp = *this;
++*this;
return tmp;
}
auto operator!=(zip_iterator const & other)
{
return !(*this == other);
}
auto operator==(zip_iterator const & other)
{
auto result = false;
return any_match(m_iters, other.m_iters);
}
auto operator*() -> value_type
{
return std::apply([](auto && ... args){
return value_type(*args...);
}, m_iters);
}
private:
std::tuple<Iters...> m_iters;
};
/* std::decay needed because T is a reference, and is not a complete type */
template <typename T>
using select_iterator_for = std::conditional_t<
std::is_const_v<std::remove_reference_t<T>>,
typename std::decay_t<T>::const_iterator,
typename std::decay_t<T>::iterator>;
template <typename ... T>
class zipper
{
public:
using zip_type = zip_iterator<select_iterator_for<T> ...>;
template <typename ... Args>
zipper(Args && ... args)
: m_args{std::forward<Args>(args)...}
{
}
auto begin() -> zip_type
{
return std::apply([](auto && ... args){
return zip_type(std::begin(args)...);
}, m_args);
}
auto end() -> zip_type
{
return std::apply([](auto && ... args){
return zip_type(std::end(args)...);
}, m_args);
}
private:
std::tuple<T ...> m_args;
};
template <typename ... T>
auto zip(T && ... t)
{
return zipper<T ...>{std::forward<T>(t)...};
}
}
Example
#include "zip.hpp"
#include <vector>
std::vector<int> a, b, c;
void foo() {
for (auto && [x, y] : zip(a, b))
c.push_back(x + z);
}
Boost.Iterators has zip_iterator you can use (example's in the docs). It won't work with range for, but you can use std::for_each and a lambda.
Here is a simple version that does not require boost. It won't be particularly efficient as it creates temporary values, and it does not generalise over containers other than lists, but it has no dependencies and it solves the most common case for zipping.
template<class L, class R>
std::list< std::pair<L,R> > zip(std::list<L> left, std::list<R> right)
{
auto l = left.begin();
auto r = right.begin();
std::list< std::pair<L,R> > result;
while( l!=left.end() && r!=right.end() )
result.push_back( std::pair<L,R>( *(l++), *(r++) ) );
return result;
}
Although the other versions are more flexible, often the point of using a list operator is make a simple one-liner. This version has the benefit that the common-case is simple.
I can do this with a template specialization I think, for nestedness of 1,2,3 (most common cases) by respectively nesting 1,2,3 for loops and referring to the types by their typenames in stl...but for arbitrary depth, without use of the preprocessor, is there a way to do this? Maybe with mpl? Or would I need a preprocessor tool as well? Right now I am doing something like this:
template<typename T, int>
struct MapDump {};
template<typename T >
struct MapDump<T,1>
{
static void dump(const T& map, string file, string header="")
{
if (!header.empty())
cout << header << endl;
for (typename T::const_iterator cIt = map.begin();
cIt != map.end();
++cIt)
cout << cIt->first << "," << cIt->second << endl;
}
};
template<typename T >
struct MapDump<T,2>
{
static void dump(const T& map, string file, string header="")
{
if (!header.empty())
cout << header << endl;
for (typename T::const_iterator it1 = map.begin();
it1 != map.end();
++it1)
for (typename T::mapped_type::const_iterator it2 = it1->second.begin();
it2 != it1->second.end();
++it2)
cout << it1->first << "," << it2->first << "," << it2->second << endl;
}
};
which I can call with, for example:
map<int, map<int, double> > m;
m[1][1] = 1.0;
m[1][2] = 1.0;
m[2][1] = 2.0;
m[2][2] = 2.0;
MapDump< map<int, map<int, double> >, 2 >::dump(m, "test.csv");
(I stripped out the fstream stuff and left std::cout to simplify the sample code here) My question is, how can I go about specializing when, say, the last level mapped_type is a container type? For example map > is technically a 2-depth construct and not a one level construct...but my nest of 2 specialization wouldn't compile for that type...any other suggestions on how to, perhaps abstract thsi further (figure out the depth of the construct at compile time as well) are welcome..thanks!
This performs the recursion over all nested types until it reaches a
non-nested type. It uses SFINAE to detect if there is a mapped_type
member typedef (You can use BOOST_HAS_XXX to create such a helper).
What it does not yet do is do collect the key values and pass them on
to the next level. You can either collect keys in a vector and keep
passing them down or figure out the nesting depth and use an
approximate tuple (this increases compile time complexity to n^2).
Do not use decltype and the for_each loop, if you want C++03
compatibility.
#include <map>
#include <iostream>
// sfinae to detect a mapped type
template<typename T>
struct has_mapped_type
{
private:
typedef char one;
typedef struct { char arr[2]; } two;
template<typename U>
struct wrap {};
template<typename U>
static one test(wrap<typename U::mapped_type>*);
template<typename U>
static two test(...);
public:
static const bool value = sizeof(test<T>(0)) == 1;
};
template<typename T, bool has_mapped_type>
// false version
struct dump_impl {
void operator()(const T& t) const {
std::cout << t << std::endl;
}
};
template<typename T>
// true version
struct dump_impl<T, true>
: dump_impl<
typename T::mapped_type
, has_mapped_type<typename T::mapped_type>::value
>
{
void operator()(const T& t) const {
for(auto& x : t) {
dump_impl<
typename T::mapped_type
, has_mapped_type<typename T::mapped_type>::value
>::
operator()(x.second);
}
}
};
template<typename T>
struct dump : public dump_impl<T, has_mapped_type<T>::value> {
void operator()(const T& t) const {
dump_impl<T, has_mapped_type<T>::value>::operator()(t);
}
};
int main()
{
std::map<int, std::map<int, double> > m;
m[1][1] = 1.0;
m[1][2] = 1.0;
m[2][1] = 2.0;
m[2][2] = 2.0;
dump<decltype(m)>()(m);
return 0;
}
Try
template<int I>
struct Int { };
template<typename T, int I>
struct MapDump
{
static void dump(const T& map, const string& file, const string& header="") {
if (!header.empty())
cout << header << endl;
dump(map, "", Int<I>());
}
private:
template<typename Map, int I1>
static void dump(const Map& map, const string& agg, Int<I1>) {
for (typename Map::const_iterator cIt = map.begin();
cIt != map.end();
++cIt) {
dump(cIt->second, (agg + boost::lexical_cast<std::string>(
cIt->first) + ", "), Int<I1-1>());
}
}
template<typename D>
static void dump(const D& d, const string& agg, Int<0>) {
cout << agg << d << endl;
}
};
Here is a simple recursive function template that will print the nested maps:
template <typename Last>
void dumpMap(const Last &last,const std::string &first)
{
std::cout << first << last << "\n";
}
template <typename A,typename B>
void dumpMap(const std::map<A,B> &last,const std::string &first=std::string())
{
typename std::map<A,B>::const_iterator i=last.begin(), i_end=last.end();
for (;i!=i_end;++i) {
std::ostringstream s;
s << first << (*i).first << ",";
dumpMap((*i).second,s.str());
}
}
You can use it like this:
map<int, map<int, double> > m;
m[1][1] = 1.0;
m[1][2] = 1.0;
m[2][1] = 2.0;
m[2][2] = 2.0;
dumpMap(m);