How Can I Make My Custom Types Iterable Using Range-Based For Loops in C ?

Using "Range-Based for Loops" with Custom Types

Custom Type Integration

To enable "range-based for loops" on your custom type, you can implement the following:

• Member Functions: Define begin() and end() member functions that return objects that act like iterators.
• Free Functions: Create free functions begin(Type&) and end(Type&) with the same namespace as your custom type, returning objects that behave like iterators.

Namespace Considerations

• If your custom type belongs to the xml namespace, define xml::begin() or xml::end() to ensure the correct namespace association.

Return Value Requirements

The objects returned by begin() and end() don't need to be actual iterators. They must meet the following requirements:

• Implement pre- , ensuring valid initialization expressions.
• Implement binary != for boolean comparison.
• Implement unary * to provide a value for assigning to the loop variable.
• Expose a public destructor.

Decoupled Types

In C 17, the types of begin and end have been decoupled. This allows the end iterator to have a different type than the begin iterator. This is useful for "sentinel" iterators that only support != with the begin iterator type, enabling efficient iteration over null-terminated char buffers.

Library Extension Example

Consider a library type some_struct_you_do_not_control that contains a vector of integers but doesn't have begin() and end() methods.

namespace library_ns {
  struct some_struct_you_do_not_control {
    std::vector<int> data;
  };
}

To make this type iterable, you can add the following functions to the library_ns namespace:

namespace library_ns {
  int* begin(some_struct_you_do_not_control& x){ return x.data.data(); }
  int* end(some_struct_you_do_not_control& x){ return x.data.data()+x.data.size(); }
  int const* cbegin(some_struct_you_do_not_control const& x){ return x.data.data(); }
  int* cend(some_struct_you_do_not_control const& x){ return x.data.data()+x.data.size(); }
  int const* begin(some_struct_you_do_not_control const& x){ return cbegin(x); }
  int const* end(some_struct_you_do_not_control const& x){ return cend(x); }
}

Now, you can iterate over the vector using range-based for loops:

library_ns::some_struct_you_do_not_control s;
for (int i : s) {
  // ...
}

Custom Type Example

For a custom type you control, you can define the begin() and end() methods directly within the type:

struct egg_carton {
  std::vector<egg> eggs;
  auto begin() { return eggs.begin(); }
  auto end() { return eggs.end(); }
  // ...
};

The above is the detailed content of How Can I Make My Custom Types Iterable Using Range-Based For Loops in C ?. For more information, please follow other related articles on the PHP Chinese website!