5

我正在设计一种机制，它将按顺序执行一组一元函数对象。这些函数对象是在运行时赋值的，问题是：这些函数对象的参数类型不同。

我想做的是这样的：

class command_sequence {
private:

/* some kind of container */

public:
    void add( FUNC_OBJ &func, PARAM val );
    void run(void);
};

class check_temperature {
public:
    void operator() (int celsius) {
        if(celsius > 26) {
            cooler.switch_on();
        }
    }
};

class log_usage {
public:
    void operator() (std::string username) {
        username.append(" logged in");
        syslog(LOG_NOTICE,username.c_str());
    }
};

command_sequence sequence;
log_usage logger;
check_temperature checker;

sequence.add(logger, std::string("administrator"));
sequence.add(checker, lobbyMeter.read_temperature());
sequence.add(logger, std::string("lecture"));
sequence.add(checker, classroomMeter.read_temperature());
sequence.run();

如果我正在编写 C 代码，我别无选择，只能以 void* 作为参数的回调函数指针。但我现在正在使用 C++，应该有一种优雅的方式来处理它。

我现在能想到的最好方法是声明一个实际上从抽象包装类继承的模板类：

class command_sequence {
private:

    class runner {
    public:
        virtual void execute(void) = 0;
    };

    template <class FUNC, typename T> class func_pair : public runner {
    private:
        FUNC &func;
        T param;
    public:
        func_pair(FUNC &f, const T &t) : func(f),param(t) { }
        void execute(void) {
            func(param);
        }
    };

    std::vector<runner*> funcQueue;

public:

    template <class FUNC, typename T> void add(FUNC &obj, const T &t) {
        funcQueue.push_back( new func_pair<FUNC,T>(obj,t) );
    }

    void run(void) {
        std::vector<runner*>::iterator itr=funcQueue.begin();
        for(;itr!=funcQueue.end();++itr) {
            (*itr)->execute();
            delete (*itr);
        }
    }
};

这种方法可以满足我的需要，但它会为每个条目分配和释放 template_pair。我不知道这是否会导致内存碎片，因为在此过程中会非常频繁地调用此过程。

有没有更好的方法来做到这一点？

4

2 回答 2

7

你真的需要分别传递一个函数对象和它的参数吗？我会使用boost::bind，在这种情况下，它可能如下所示：

void check_temperature( int celsius )
{
    if(celsius > 26) {
        cooler.switch_on();
    }
};

void log_usage( std::string username ) 
{
    username.append(" logged in");
    syslog(LOG_NOTICE,username.c_str());
};

// keep actions
typedef std::vector< boost::function<void()> > func_arr_t;
func_arr_t actions;
actions.push_back( boost::bind( &log_usage, "administrator" ) );
actions.push_back( boost::bind( &check_temperature, lobbyMeter.read_temperature() ) );
actions.push_back( boost::bind( &log_usage, "lecture" ) );
actions.push_back( boost::bind( &check_temperature, classroomMeter.read_temperature() ) );

// run all
for ( func_arr_t::const_iterator it = actions.begin(); it != actions.end(); ++it )
    (*it)();

在这种情况下command_sequence，将只保留一个函数对象数组。

于 2011-07-08T15:45:47.743 回答
4

由于一元函数的参数在您将其添加到序列时似乎是固定的，因此您可以使用boost::function使您的序列接受零参数函数对象，然后boost::bind所需的参数，例如

class command_sequence {
public:
    void add( boost::function<void(void)> functor );
};

/* ... as before ... */

log_usage logger;
check_temperature checker;

sequence.add( boost::bind<void>(logger, "administrator") );
sequence.add( boost::bind<void>(checker, lobbymeter.read_temperature()) );

请注意，您必须<void>将调用指定为模板参数，boost::bind因为它不能自动推断函数对象的返回类型。result_type或者，您可以公开在类定义中调用的公共 typedef以避免这种情况，即

class log_usage
{
public:
    typedef void result_type;
    void operator() (const std::string& message)
    {
        // do stuff ...
    }
};

/* ... */

sequence.add(boost::bind(logger, "blah")); // will now compile
于 2011-07-08T15:59:35.037 回答