Do this: // defined in boost/utility.hpp, by the way template <typename Iter> Iter next(Iter iter) { return ++iter; } // first check we aren’t going to kill ourselves // then check if the iterator after itr is the end if ((itr != Mine.end()) && (next(itr) == Mine.end())) { // points at the last element } … Read more
The concept of an iterator is a little different in Perl. You basically want to return a one-use subroutine “closed” over the persistent variables. use bigint; use strict; use warnings; sub fibonacci { my $limit = 10**( shift || 0 ); my ( $a, $b ) = ( 0, 1 ); return sub { return … Read more
Before voting on this answer, please test (and verify) this on your machine and comment/add the results. Note that I used a vector size of 1000*1000*1000 for my tests. Currently, this answer has 19 upvotes but only one posted results, and these results did not show the effect described below (though obtained with a different … Read more
Looking at std::reverse_iterator‘s libstdc++ implementation reveals something interesting: /** * @return A reference to the value at @c –current * * This requires that @c –current is dereferenceable. * * @warning This implementation requires that for an iterator of the * underlying iterator type, @c x, a reference obtained by * @c *x remains valid … Read more
The behavior of swap has been clarified considerably in C++11, in large part to permit the Standard Library algorithms to use argument dependent lookup (ADL) to find swap functions for user-defined types. C++11 adds a swappable concept (C++11 ยง17.6.3.2[swappable.requirements]) to make this legal (and required). The text in the C++11 language standard that addresses your … Read more
With auto and the range-based for-loops of C++11 this becomes relatively elegant: std::vector< std::unique_ptr< YourClass >> pointers; for( auto&& pointer : pointers ) { pointer->functionOfYourClass(); } The reference & to the std::unique_ptr avoids the copying and you can use the uniqe_ptr without dereferencing.
Unless you’re using an older Ruby like 1.8 (I think this was added in 1.9 but I’m not sure), you can use each.with_index(1) to get a 1-based enumerator: In your case it would be like this: <% @document.data.length.each.with_index(1) do |element, index| %> … <% end %>
In your particular case, it’s because you have implemented your trait for an iterator of String, but your vector is providing an iterator of &str. Here’s a more generic version: use std::collections::HashSet; use std::hash::Hash; struct Unique<I> where I: Iterator, { seen: HashSet<I::Item>, underlying: I, } impl<I> Iterator for Unique<I> where I: Iterator, I::Item: Hash + … Read more
Iterators are glorified pointers. Iterator invalidation is a lot like pointer invalidation; it means it suddenly points to junk data. Because it’s very natural but wrong to do things like this: for(iterator it = map.begin(); it != map.end(); ++it) { map.erase(it->first); // whoops, now map has been restructured and iterator // still thinks itself is … Read more
While the break solution works, I think a more functional approach really suits this problem. You want to take the first 10 elements and print them so try items.take(10).each { |i| puts i.to_s }