Create a class that encapsulates some number of the following:
a "receiver" object
the method to invoke
the arguments to pass
Instantiate an object for each "callback"
Pass each object to its future "sender"
When the sender is ready to callback to the receiver, it calls execute()
#include <iostream> #include <string> using namespace std;
// 1. Create a class that encapsulates an object and a member function
// a pointer to a member function (the attribute's name is "method")
Person *object; //
Command(Person *obj = 0, void(Person:: *meth)() = 0)
object = obj; // the argument's name is "meth"
method = meth;
(object-> *method)(); // invoke the method on the object
// cmd is a "black box", it is a method invocation
// promoted to "full object status"
Person(string n, Command c): cmd(c)
name = n;
// "this" is the sender, cmd has the receiver
cout << name << " is talking" << endl;
cmd.execute(); // ask the "black box" to callback the receiver
cout << name << " is passing on" << endl;
// 4. When the sender is ready to callback to the receiver,
// it calls execute()
cout << name << " is gossiping" << endl;
cout << name << " is listening" << endl;
// Fred will "execute" Barney which will result in a call to passOn()
// Barney will "execute" Betty which will result in a call to gossip()
// Betty will "execute" Wilma which will result in a call to listen()
Person wilma("Wilma", Command());
// 2. Instantiate an object for each "callback"
// 3. Pass each object to its future "sender"
Person betty("Betty", Command(&wilma, &Person::listen));
Person barney("Barney", Command(&betty, &Person::gossip));
Person fred("Fred", Command(&barney, &Person::passOn));
Fred is talking
Barney is passing on
Betty is gossiping
Wilma is listening