Is Iterable-like behavior in C++ attainable?

Question

Java allows classes to reveal Iterable types so clients can traverse some instance's collection of data, like so:

public class MyClass
{
    private ArrayList<String> strings;
    private ArrayList<Integers> ints;
    public MyClass() { /* generate data ... */ }
    public Iterable<String> allStrings() {return strings;}
    public Iterable<Integer> allInts() {return ints;}
}

This has always struck me as "clean" because it maintains encapsulation, allowing me to change the ArrayLists to LinkedLists if I wanted to and is still convenient to the client in constructs such as for(String s : myClassInstance.allStrings()) //....

In C++, however, if I want to allow the client to use my for-loop, in absence of an Iterable, I need to return a const vector<T>& or whatever, which is obviously not too great.

Defining template<> begin<my_class> {/*...*/} and friends is nice, but only if my_class has one collection to iterate over. What else can I do?

Answer 1

just make Iterable in C++

template<class T, class U>
struct Iterable
{
    T _begin;
    U _end;

    Iterable(T begin, U end)
    : _begin(begin), _end(end)
    {}

    T begin()
    {
        return _begin;
    }

    U end()
    {
        return _end;
    }
};

template<class T, class U>
Iterable<T,U> make_iterable(T t, U u)
{
    return Iterable<T,U>(t, u);
}

struct MyClass 
{
    std::vector<int> _ints;
    std::vector<std::string> _strings;

    auto allInts() -> decltype(make_iterable(_ints.begin(), _ints.end()))
    {
        return make_iterable(_ints.begin(), _ints.end());
    }

    auto allStrings() -> decltype(make_iterable(_strings.begin(), _strings.end()))
    {
        return make_iterable(_strings.begin(), _strings.end());
    }
};

then use it like

for (auto i : foo.allInts())
{
    cout << i << endl;
}

for (auto i : foo.allStrings())
{
    cout << i << endl;
}

live example