Ufdjrw

I am attempting to write a template function that iterates over a user-specified field within some collection of structs. For example, I want to write the following C++:

struct Example 
 int a;
 bool b;
;

template<std::function<Field& (Class)> GetField, typename Field, typename Class>
void myFunc(std::iterator<Class> begin, size_t const length) 
 cout << length << endl;
 for (size_t i 0 ; i < length; ++begin, ++i) 
 Field const &field GetField(*begin) ;
 // Forward field to some other template function
 anotherTemplateFunction<Field>(field);
 


void main() 
 Example exArray[] 5, true, 8, false ;
 std::list<Example> exList exArray, exArray + _countof(exArray) 

 // Examples of how I would like to call myFunc...
 myFunc<Example::a>(exArray, _countof(exArray));
 myFunc<Example::b>(exList.begin(), exList.size());

The above doesn't work, but hopefully the intent is clear. How can I write the myFunc template method to accomplish generic iteration over some field of each iterated item? Alternatively, if there is some way (in Boost or the Standard Library) to directly create an iterator over exArray[i].a, that would also be acceptable.

It's simple if you know the pointer to member syntax and the likes. Unfortunately is so rarely used, is kind of an esoteric feature of the language:

template <class T> void foo(T);

template <auto Field, class It>
auto myFunc(It begin, It end)

 for (; begin != end; ++begin)
 
 foo((*begin).*Field);
 


int main()

 std::vector<Example> v5, true, 8, false;

 myFunc<&Example::a>(v.begin(), v.end()); // will call foo<int>(5) , foo<int>(8)
 myFunc<&Example::b>(v.begin(), v.end()); // will call foo<bool>(true) , foo<bool>(false)

For the template <auto Field you need C++17.

For C++11 the syntax is more verbose:

template <class T, class F, F T::* Field, class It>
void myFunc(It begin, It end)
 /* same */ 

int main()

 std::vector<Example> v5, true, 8, false;

 myFunc<Example, int, &Example::a>(v.begin(), v.end()); // will call foo<int>(5) , foo<int>(8)
 myFunc<Example, bool, &Example::b>(v.begin(), v.end()); // will call foo<bool>(true) , foo<bool>(false)

A little bit OT to your question, but I don't understand why you complicate yourself with that initialization of std::list. In C++ your first container of choice should be std::vector.

Also there is no std::iterator

What I usually use is something like:

void main() 
 std::array<Example, 2> exArray 5, true, 8, false ;
 std::list<Example> exList exArray.begin(), exArray.end() ;

 auto access_a = [](Example& e)->int& return e.a;;
 auto access_b = [](Example& e)->bool& return e.b;;
 myFunc(exArray.begin(), exArray.end(), access_a);
 myFunc(exList.begin(), exList.end(), access_b);


template<class ForwardIt, class Accessor>
void myFunc(ForwardIt begin,ForwardIt end, Accessor accessor) 
 cout << end - begin << endl;
 for (auto it = begin; it != end; it++) 
 // Forward field to some other template function
 anotherTemplateFunction(accessor(*it));
 

Please notice how I used std::array instead of a raw c style array.
If you have access to a c++11 compiler, std::array (or std::vector) should always be preferred over raw c arrays. ES.27

In order to need less boilerplate code, consider using some serialization libraries which solve this "iterating over class fields" problem, for example boost serialization or magic get.