template <class T>
class MyContainer
{
   typedef std::vector<T> Inner;
   typedef std::vector<Inner> Outer;
   Outer contents_;
public:
   class iterator
   {
      friend class MyContainer;
      Outer::iterator it1_;
      Inner::iterator it2_, it2end_;
      bool isEnd_; // <<<<< костыль
      iterator(Outer::iterator it1, bool) : it1_(it1), isEnd(false) {
         it2_ = it1_->begin();
         it2end_ = it1_->end();
      }
      iterator(Outer::iterator it1) : it1_(it1), isEnd(true) {}
   public:
      T& operator*() { return *it2_; }
      iterator& operator++() {
         if(++it2_==it2end_) {
            ++it1_;
            it2_ = it1_->begin();
            it2end_ = it1_->end();
         }
      }
      bool operator==(iterator it) const {
         return it1_==it.it1_ &&
            (isEnd_==it.isEnd_ || it2_==it.it2_);
      }
   };
   
   iterator begin() { return iterator(contents_.begin(), true); }
   iterator end() { return iterator(contents_.end()); }
};

LG>template <class T>
LG>   class iterator
LG>   {
LG>      Outer::iterator it1_;
LG>      Inner::iterator it2_, it2end_;

делай по-другому, храни два внешних итератора (текущий и конечный) и один внутренний -- текущий.

LG>      iterator& operator++() {
LG>         if(++it2_==it2end_) {
LG>            ++it1_;
LG>            it2_ = it1_->begin();
LG>            it2end_ = it1_->end();
LG>         }

здесь проблема. мало того что при it1 == end получишь неприятности, но и при пустом внутреннем контейнере разименуешь it2end_.

LG>      }

LG>      bool operator==(iterator it) const {
LG>         return it1_==it.it1_ &&
LG>            (isEnd_==it.isEnd_ || it2_==it.it2_);

здесь можно обойтись сравнением it2_==it.it2_

LG>      }
LG>   };

LG>>      }

LG>>      bool operator==(iterator it) const {
LG>>         return it1_==it.it1_ &&
LG>>            (isEnd_==it.isEnd_ || it2_==it.it2_);

NB>здесь можно обойтись сравнением it2_==it.it2_

чуть подумал. похоже, конец вектора все-же придется проверять  :(  it1_ == it1end_ ? it1_ == it.it1_ : it2_ == it.it2_.
ну или завернуть it2_ в optional.

LG>>      }
LG>>   };

template<class I, class J> struct jagged_iterator
{
  I i; J j;

  jagged_iterator(I i0, J j0) // при условии, что j0 относится к строке *i
  {
    i = i0; j = j0;
    skip_empty_lines(); // возможно, что мы встали в конец первой строки, - нужно прыгнуть вперёд.
  }
  jagged_iterator operator++()
  {
    // если это инкремент, то мы заведомо не в конце текста и не в конце строки (стоим на какой-то букве)
    ++j; // прыгнем на одну букву
    skip_empty_lines(); // и перепрыгнем, при необходимости, через конец строки и следующие пустые строки
  }
  void skip_empty_lines()
  {
    if(j==end(*i)) // если встали на конец строки,
    {
      do { ++i; } while(begin(*i)==end(*i)); // начнём прыгать по строкам, пока не найдём непустую
      j = begin(*i); // и встанем на её начало
    }
  }
  bool operator==(jagged_iterator const& other) const
  {
    return i==other.i && j==other.j;
  }

  decltype(*j) operator* () const { return *j; }
};

template<class I, class J> struct jagged_iterator
{
  I i;
  I ie; J j;

  jagged_iterator(I i0, I iend, J j0) // при условии, что если i!=iend, j0 относится к строке *i
  {
    i = i0; ie = iend; j = j0;
    skip_empty_lines();
  }
  jagged_iterator operator++()
  {
    ++j;
    skip_empty_lines();
  }
  void skip_empty_lines()
  {
    if(i!=ie && j==end(*i)) // обязательно нужны проверки на валидность i: здесь...
    {
      do { ++i; } while(i!=ie && begin(*i)==end(*i)); //... здесь, ...
      if(i!=ie) j = begin(*i); //... и здесь.
    }
  }
  bool operator==(jagged_iterator const& other) const
  {
    // равенство тоже более хитрое
    return i==other.i && (i==ie ? other.i==other.ie || j==other.j);
  }

  decltype(*j) operator* () const { return *j; }
};

for(I i=i0; i!=iend; ++i)
  for(J j=begin(*i); j!=end(*i); ++j)
    process(*j);

I i;
J j;

Li0:
    i=i0;
    goto Li2;
Li1:
    ++i;
Li2:
    if(i==iend) goto Li3;
Lj0:
        j=begin(*i);
        goto Lj2;
Lj1:
        ++j;
Lj2:
        if(j==end(*i)) goto Lj3;
Lp0:
            process(*i);
Lp1:
            goto Lj1;
Lj3:
        goto Li1;
Li3:
    ;

#include "generator.h"

template<typename T> 
   $generator(all_elements) 
 {
    size_t r,c;
    vector<vector<T>> &cont;

    all_elements(vector<vector<T>> &c): cont(c), r(0),c(0) {}

    $emit(T)

      for(; r < cont.size(); ++r)
        for( c = 0; c < cont[r].size(); ++c )
          $yield( cont[r][c] );

    $stop;
};

  vector<vector<int>> ints2d; 
  ...

  int sum = 0;
  all_elements<int> all(ints2d);

  for(int el; all(el);) 
    sum += el;

  cout << sum << endl;

#include <vector>
#include <iostream>
#include "generator.h"

using namespace std;

template<typename T> 
   $generator(all_elements) 
 {
    size_t r,c;
    vector<vector<T>> &cont;

    all_elements(vector<vector<T>> &c): cont(c), r(0),c(0) {}

    $emit(T)
      for(; r < cont.size(); ++r)
        for( c = 0; c < cont[r].size(); ++c )
          $yield( cont[r][c] );
    $stop;
};


int main()
{
  vector<vector<int>> ints2d;
  ints2d.resize(2); ints2d[0].resize(2); ints2d[1].resize(2);
  ints2d[0][0] = 0; ints2d[0][1] = 1; ints2d[1][0] = 2; ints2d[1][1] = 3; 

  int sum = 0;
  all_elements<int> all(ints2d);

  for(int el; all(el);) 
    sum += el;

  cout << sum << endl;
  
    return 0;
}

TrivialInputIterator x;
bool{ empty(x) };
++x;
*x;

// NOT TESTED!
template<typename Outer>
class JaggedIterator // Models TrivialInputIterator
{
    Outer first, last;
    using Inner = decltype(begin(*first)); // TODO: use iterator_traits
    Inner inner_first;
    using value_type = decltype(*inner_first);
    
    void skip_empty()
    {
        assert(first != last);
        while(inner_first == end(*first))
        {
            ++first;
            if(first == last) break;
            inner_first = begin(*first);
        }
    }
public:
    JaggedIterator(Outer first, Outer last)
        : first(first), last(last)
    {
        if(first != last)
        {
            inner_first = begin(*first);
            skip_empty();
        }
    }
    JaggedIterator &operator++()
    {
        assert(inner_first != end(*first));
        ++inner_first;
        if(first != last)
            skip_empty();
        return *this;
    }
    const int &operator*() const
    {
        return *inner_first;
    }
    friend bool empty(const JaggedIterator &x)
    {
        return x.first == x.last;
    }
};

int main()
{
    vector<vector<int>> x = {{}, {}, {1,2,3}, {}, {4, 5, 6}, {7,8}, {9}};

    for(auto x : make_range(make_jagged(begin(x), end(x))))
        cout << x << " ";
}

// Refer http://ericniebler.com/2013/11/07/input-iterators-vs-input-ranges/ ,
//       http://boost.2283326.n4.nabble.com/range-fat-iterators-td4654575.html

#include <boost/iterator/iterator_facade.hpp>
#include <type_traits>
#include <iterator>
#include <iostream>
#include <cassert>

using namespace boost;
using namespace std;

template<typename TrivialInputIterator>
class InputRangeAdaptor
{
    mutable TrivialInputIterator it;
    // Cache during increment?
    // Or maybe underlying iterator/range should do it by himself.

    // iterator_traits?
    using reference = decltype(*it);
    using value_type = typename std::remove_reference<reference>::type;
public:
    class iterator: public iterator_facade
                    <
                        iterator, value_type, input_iterator_tag, reference
                    >
    {
        const InputRangeAdaptor *range = nullptr;
    public:
        iterator() = default;
        explicit iterator(const InputRangeAdaptor &range)
            : range{empty(range.it) ? nullptr : &range}
        {}
    private:
        friend class boost::iterator_core_access;
        void increment()
        {
            ++range->it;
            if(empty(range->it))
                range = nullptr;
        }
        bool equal(iterator x) const
        {
            return range == x.range;
            // Another option: move checks for emptiness here from increment.
            // That would be faster for cases when we do not check for equality,
            //   i.e. std::copy_n.
            // But such equality check will be more complicated and slower
        }
        reference dereference() const
        {
            return *range->it;
        }
    };

    explicit InputRangeAdaptor(TrivialInputIterator it)
        : it(it)
    {}
    
    iterator begin() const
    {
        return iterator{*this};
    }
    iterator end() const
    {
        return iterator{};
    }
};

template<typename TrivialInputIterator>
InputRangeAdaptor<TrivialInputIterator> make_range(TrivialInputIterator x)
{
    return InputRangeAdaptor<TrivialInputIterator>{x};
}

/*****************************************************************************/

class NullTerminated  // Models TrivialInputIterator
{
    const char *position;
public:
    explicit NullTerminated(const char *position)
        : position{position}
    {}
    NullTerminated &operator++()
    {
        ++position;
        return *this;
    }
    const char &operator*() const
    {
        return *position;
    }
    friend bool empty(const NullTerminated &x)
    {
        return *x == 0;
    }
};

/*****************************************************************************/

#include <initializer_list>
#include <iterator>
#include <cassert>
#include <vector>

// NOT TESTED!
template<typename Outer>
class JaggedIterator // Models TrivialInputIterator
{
    Outer first, last;
    using Inner = decltype(begin(*first)); // TODO: use iterator_traits
    Inner inner_first;
    using value_type = decltype(*inner_first);
    
    void skip_empty()
    {
        assert(first != last);
        while(inner_first == end(*first))
        {
            ++first;
            if(first == last) break;
            inner_first = begin(*first);
        }
    }
public:
    JaggedIterator(Outer first, Outer last)
        : first(first), last(last)
    {
        if(first != last)
        {
            inner_first = begin(*first);
            skip_empty();
        }
    }
    JaggedIterator &operator++()
    {
        assert(inner_first != end(*first));
        ++inner_first;
        if(first != last)
            skip_empty();
        return *this;
    }
    const int &operator*() const
    {
        return *inner_first;
    }
    friend bool empty(const JaggedIterator &x)
    {
        return x.first == x.last;
    }
};

template<typename Outer>
auto make_jagged(Outer first, Outer last)
{
    return JaggedIterator<Outer>{first, last};
}

int main()
{
    using namespace std;
    vector<vector<int>> x = {{}, {}, {1,2,3}, {}, {4, 5, 6}, {7,8}, {9}};

    for(auto x : make_range(make_jagged(begin(x), end(x))))
        cout << x << " ";
    cout << endl;
}

#include <boost/coroutine/all.hpp>
#include <initializer_list>
#include <iostream>
#include <vector>

int main()
{    
    using namespace std;
    using namespace boost;
    using namespace coroutines;
    typedef coroutine<int> Coro;

    vector<vector<int>> v = {{}, {}, {1,2,3}, {}, {4, 5, 6}, {7,8}, {9}};

    Coro::pull_type coro([&](Coro::push_type &yield)
    {
        for(auto &inner : v)
            for(auto &x : inner)
                yield(x);
    });

    for(auto x : coro) // InputRange
        cout << x << " ";
}

#include <initializer_list>
#include <iostream>
#include <iterator>
#include <vector>

template<typename Range, typename F>
F for_each_jagged(Range &r, F yield)
{
    for(auto &inner : r)
        for(auto &x : inner)
            yield(x);
    return yield;
}

int main()
{
    using namespace std;
    vector<vector<int>> v = {{}, {}, {1,2,3}, {}, {4, 5, 6}, {7,8}, {9}};

    for_each_jagged(v, [](auto x)
    {
        cout << x << " ";
    });
}

int main()
{
    vector<vector<int>> outer = {{}, {}, {1,2,3}, {}, {4, 5, 6}, {7,8}, {9}};

    auto generator = make_generator(
        DO(Generator,
            (inner, outer)
            (x, inner)
            (_, yield(x))
        )
    );
    for(auto x : generator)
        cout << x << " ";
    cout << endl;
}

template<typename T> 
   $generator(all_elements) 
 {
    size_t r,c;
    vector<vector<T>> &cont;
    bool forward;

    all_elements(vector<vector<T>> &c, bool pforward = true): cont(c), r(0),c(0), forward(pforward) {}

    $emit(T)

    if(forward)
      for(r = 0; r < cont.size(); ++r)
        for( c = 0; c < cont[r].size(); ++c )
          $yield( cont[r][c] );
    else 
      for(r = cont.size() - 1; r < cont.size(); --r)
        for( c = cont[r].size() - 1; c < cont[r].size(); --c )
          $yield( cont[r][c] );

    $stop;
};

#include <vector>
#include <iostream>
#include <assert.h>

template<class C>
class l2_iterator
{
    typedef typename C::iterator outer_iterator;
    typedef typename C::value_type inner_container;
    typedef typename inner_container::iterator inner_iterator;
public:
    typedef typename inner_iterator::value_type value_type;
    typedef typename inner_iterator::pointer pointer;
    typedef typename inner_iterator::reference reference;
private:
    l2_iterator(C& c, outer_iterator o_it) 
        : container_(&c), o_it_(o_it) 
    {}
public:
    static l2_iterator begin(C& c) { 
        l2_iterator ret(c, c.begin());
        if(!c.empty()) ret.i_it_ = c.begin()->begin();
        return ret;
    }
    static l2_iterator end(C& c) { 
        return l2_iterator(c, c.end());
    }
public:
    l2_iterator() : container_(0) {}
    l2_iterator& operator++() {
        ++i_it_;
        while(i_it_ == o_it_->end())
        {
            ++o_it_;
            if(o_it_ == container_->end())
                break;
            i_it_ = o_it_->begin();
        }
        return *this;
    }
    bool operator ==(const l2_iterator& other) const {
        assert(container_ &&  container_ == other.container_);
        return o_it_ == other.o_it_ && (o_it_ == container_->end() || i_it_ == other.i_it_);
    }
    bool operator !=(const l2_iterator& other) const {
        return !(*this == other);
    }
    reference operator*() const { return *i_it_; }
    pointer operator->() const { return &(*i_it_); }
private:
    C* container_;
    outer_iterator o_it_;
    inner_iterator i_it_;
};


int main( int argc, char* argv[] )
{
    typedef std::vector<int> inner;
    typedef std::vector<inner> outer;
    typedef l2_iterator<outer> iterator;

    outer c;
    c.resize(3);
    for(int i=0;i<10;++i)
        c[i%3].push_back(i);

    for(iterator it=iterator::begin(c); it!=iterator::end(c); ++it)
        std::cout << *it << std::endl;

    return 0;
}

TrivialInputIterator it;
bool{ empty(it) };
++it;
*it;

TrivialInputIterator first;
std::copy_n(first, n, out);