有没有办法在 C++ 中为基于范围的循环设置偏移量？

Question

Suppose that these classes have an inner array of AnotherObjectClass type that can be accessed through a function called GetAnotherObjectClassTerms.

#include<iostream>

int main() {

    // Suppose a default constructor that assigns values to the arrays
    AnObjectClass obj1;
    AnObjectClass obj2;

    for (AnotherObjectClass term1 : obj1.GetAnotherObjectClassTerms) {
        for (AnotherObejctClass term2 : obj2.GetAnotherObjectClassTerms) {
            if (term1 > term2) {
                std::cout << "Term 1 is greater than term 2" << std::endl;
            } else {
                std::cout << "Term 1 is not greater than term 2" << std::endl;
                // OFFSET THIS INNER LOOP so it doesn't iterate through all the items again.
                break;
            }
        }
    }
}

I can do this in a normal for loop by creating a variable that holds that last index, so that when it starts iterating, it starts from that specific position.

The following code is to show my problem using a traditional for-loop as requested.

for (unsigned short i = 0, temp = 0; i < 3; i++) {
    for (unsigned short j = temp; j < 3; j++) {
        // This traditional for-loop iterates through a different range
        // whenever the 'temp' value is increased

        if (j > i) {
            std::cout << j << " > " << i << std::endl;
        }
        else {
            std::cout << j << " <= " << i << std::endl;
            temp++;
        }
    }
}

The output of the code above would be:

Output #1: 0 <= 0

Output #2: 1 > 0

Output #3: 2 > 0

Output #4: 1 <= 1

Output #5: 2 > 1

Output #6: 2 <= 2

As you can see, the inner loop doesn't iterate from the "beginning" whenever the variable temp is incremented.

So my question is: can this be done in a range-based for loop? If so, how this offset can be applied to a range-base for loop? Or, should I completely avoid this and go with a normal for-loop?

The real problem that I'm having is that I need the inner loop to start by an offset by +1 when the break statements is reached .

Take into account that the range-based for is looping through the elements of an array.

Answer 1

If you can use Boost, you can use boost::adaptors::sliced to get a slice of your range. The following is a complete example:

#include <cstddef> // std::size_t
#include <iostream>
#include <iterator>
#include <boost/range/adaptor/sliced.hpp>

int main() {
    int a[] = {0,1,2}, b[] = {0,1,2};

    std::size_t off = 0;
    for (int term1 : a) {
        for (int term2 : b | boost::adaptors::sliced(off, std::size(b))) {
                                                          // ^^^^^^^^^ C++17 feature
            if (term1 > term2) {
                std::cout << "Term 1 is greater than term 2" << std::endl;
            } else {
                std::cout << "Term 1 is not greater than term 2" << std::endl;
                ++off;
                break;
            }
        }
    }
}

Output:

Term 1 is not greater than term 2
Term 1 is not greater than term 2
Term 1 is not greater than term 2

You can also implement a simple class, say Offset . When combined with a range, it returns a proxy class with begin() and end() member functions (so that it is able to behave like a range), say View , which represents the offseted range.

Example:

#include <cstddef> // std::size_t
#include <iostream>
#include <iterator>
#include <utility>

struct Offset {
    std::size_t _offset;
};

constexpr Offset offset(std::size_t s)
{
    return {s};
}

template <typename Iterator>
struct View {
    constexpr Iterator begin() const {return _begin;}
    constexpr Iterator end() const {return _end;}
    Iterator _begin;
    Iterator _end;
};

// Combine a range with an Offset using operator| like boost::adaptors::sliced
template <typename Range>
auto operator |(Range &&range, const Offset &offset) 
    -> View<decltype(std::begin(std::forward<Range>(range)))> 
{
    return {
        std::begin(std::forward<Range>(range)) + offset._offset, 
        std::end(std::forward<Range>(range))
    };
}

int main() {
    int a[] = {0,1,2}, b[] = {0,1,2};

    std::size_t off = 0;
    for (int term1 : a) {
        for (int term2 : b | offset(off)) {
            if (term1 > term2) {
                std::cout << "Term 1 is greater than term 2" << std::endl;
            } else {
                std::cout << "Term 1 is not greater than term 2" << std::endl;
                ++off;
                break;
            }
        }
    }
}