Hi,

I have a class (A) which contains 'Listeners' or 'Observers' which need to be informed when certain things happen in class A. This currently involves iterating over all listeners and calling a certain notification method for example:

for(Listener listener : listeners)
{
   listener->InformOfSomething(1, 2, 3, 4);
}

I was wondering if there is any convenient way in c++11 to reduce this to a one-liner without having to create additional functions or use lambdas (or even remove the brackets ;)

The approach I'm looking for would be something similar to jQuery where functions act on collections of objects as opposed to single items. For e.g. maybe something as simple as this:

$(listeners).InformOfSomething(1, 2, 3, 4);

(please forgive the shameless copy of jQuery syntax)

Where the $ syntax acts in a similar way to range-based for loops and requires begin() and end() functions on the 'listeners' param which then iterates the collection and substitutes the item in the collection with first parameter of the proceeding function (or more specifically the 'this' pointer when using a class member function).

Anything like this in c++11 or any better way to do it?

Thanks.

Just write some templated helper functions, if std::for_each() doesn't do what you want.

Feel free to take mine. The header needs to be cleaned up a bit, but meh.

ForEach(array, DoSomething, 17, "Text"); //Global functions, functors, or lambdas.
ForEach(array, &Element::DoSomething, 17, "Text"); //Member functions
ForEachPtr(arrayOfPtrs, &Element::DoSomething, 17, "Text"); //Vector of smart pointers.

If you really wanted to, you could probably cobble together something that looked like this:

ForEach(array, &Element::DoSomething)(17, "Text"); 

Or this:

ForEach(array).(&Element::DoSomething, 17, "Text");  

...but I don't think this is possible:

ForEach(array).DoSomething(17, "Text"); //Not possible.

Not in straight C++ anyway - with the preprocessor you could do:

#define ForEach(container) for(auto &element : container) element

ForEach(arrayOfObjects).DoSomething(17, "Test");

[ideone]

You'd need a separate macro for const iteration. I'd stick to the templated functions, though.

#include <iostream>
#include <vector>

class Listener {
	public:
		void InformOfSomething(int a, int b, int c, int d) {
			std::cout << "Thank you for informing me about " << a << ", " << b << ", " << c << ", " << d << '\n';
		}
};

template<typename C, typename F, typename ...Args>
static inline void callVector(C &&it, F &&f, Args&& ...args) {
	for(auto &t : it)
		(t.*f)(std::forward<Args>(args)...);
}

int main() {
	std::vector<Listener> listeners(3);

	callVector(listeners, &Listener::InformOfSomething, 7, 8, 9, 0);
}

Almost at the $ syntax, and just for fun :)

#include <iostream>
#include <vector>

class Listener {
	public:
		void InformOfSomething(int a, int b, int c, int d) {
			std::cout << "Thank you for informing me about " << a << ", " << b << ", " << c << ", " << d << '\n';
		}
};

template<typename C, typename F>
struct Caller {
	C &c;
	F f;
	Caller(C &c, F &f) : c(c), f(f) {}

	template<typename ...Args>
	void operator()(Args&& ...args) {
		for(auto &t : c)
			(t.*f)(std::forward<Args>(args)...);
	}
};

template<typename C, typename F>
static inline Caller<C, F> operator->*(C &c, F &&f) {
	return Caller<C, F>(c, f);
}

struct Int {
	operator int() {
		return rand();
	}
};

int main() {
	std::vector<Listener> listeners(3);

	(listeners->*&Listener::InformOfSomething)(2, Int(), 4, 5);
}

template<typename C, typename F>
static inline Caller<C, F> operator->*(C &c, F &&f) {