ns-3 Manual, Release ns-3-dev
What is needed is a way to decouple the calling function from the called class completely. This requirement led to the
development of the Functor.
A functor is the outgrowth of something invented in the 1960s called a closure. It is basically just a packaged-up
function call, possibly with some state.
A functor has two parts, a specific part and a generic part, related through inheritance. The calling code (the code that
executes the callback) will execute a generic overloaded operator() of a generic functor to cause the callback to be
called. The called code (the code that wants to be called back) will have to provide a specialized implementation of
the operator() that performs the class-specific work that caused the close-coupling problem above.
With the specific functor and its overloaded operator() created, the called code then gives the specialized code to
the module that will execute the callback (the calling code).
The calling code will take a generic functor as a parameter, so an implicit cast is done in the function call to convert the
specific functor to a generic functor. This means that the calling module just needs to understand the generic functor
type. It is decoupled from the calling code completely.
The information one needs to make a specific functor is the object pointer and the pointer-to-method address.
The essence of what needs to happen is that the system declares a generic part of the functor:
template <typename T>
class Functor
{
public:
virtual int operator()(T arg) = 0;
};
The caller defines a specific part of the functor that really is just there to implement the specific operator() method:
template <typename T, typename ARG>
class SpecificFunctor : public Functor<ARG>
{
public:
SpecificFunctor(T
*
p, int (T::
*
_pmi)(ARG arg))
{
m_p = p;
m_pmi = _pmi;
}
virtual int operator()(ARG arg)
{
(
*
m_p.
*
m_pmi)(arg);
}
private:
int (T::
*
m_pmi)(ARG arg);
T
*
m_p;
};
Here is an example of the usage:
class A
{
public:
A(int a0) : a(a0) {}
int Hello(int b0)
{
std::cout << "Hello from A, a = " << a << " b0 = " << b0 << std::endl;
(continues on next page)
12 Chapter 2. Simulator
剩余290页未读，继续阅读
