Question

Since code speaks better than words, would you use this:

struct StringEvent
{
    const void* source;
    const std::string str;

    StringEvent(const void* source, const std::string& str)
        : source(source), str(str) 
    { }
};

class StringEventListener
{
public:
    virtual void handler(const StringEvent& event) = 0;
}

class Test : public StringEventListener
{
public:
    void handler(const StringEvent& event) 
    { 
        std::cout << event.str << std::endl; 
    }
}

class EventSource
{
public:
    EventSource(StringEventListener* listener) 
    { 
        listener->handler(StringEvent(this, std::string("foo"))); 
    } 
}

int main()
{
    Test test;

    EventSource(&test);
}

over this?

class Test 
{
public:
    void handler(const std::string& str) 
    { 
        std::cout << str << std::endl; 
    }
};

class EventSource
{
public:
    EventSource(const boost::function<void (const std::string&)>& funcPtr)
    {
        funcPtr(std::string("foo"));
    }
};

int main()
{
    Test test;

    EventSource(boost::bind(&Test::handler, &test, _1));
}

to make the class EventSource call test.handler("foo")?

Coming from the Java/C# world I find the first approach more intuitive, albeit verbose, but is it reccomanded to use in real-life situations, or does it cause more problems than it’s worth/performance hits?

Answer 1

I would absolutely not use the first version. That’s terrible. The second version is far superior- it can be lambdas and whatnot as well.

Also, boost::function is not a function pointer.