6

我想将具有相似签名的函数存储在集合中以执行以下操作：

f(vector<Order>& orders, vector<Function>& functions) {
    foreach(process_orders in functions) process_orders(orders);
}

我想到了函数指针：

void GiveCoolOrdersToBob(Order);
void GiveStupidOrdersToJohn(Order);

typedef void (*Function)(Order);
vector<Function> functions;
functions.push_back(&GiveStupidOrdersToJohn);
functions.push_back(&GiveCoolOrdersToBob);

或多态函数对象：

struct IOrderFunction {
    virtual void operator()(Order) = 0;
}

struct GiveCoolOrdersToBob : IOrderFunction {
    ...
}

struct GiveStupidOrdersToJohn : IOrderFunction {
    ...
}

vector<IOrderFunction*> functions;
functions.push_back(new GiveStupidOrdersToJohn());
functions.push_back(new GiveCoolOrdersToBob());
4

3 回答 3

9

前提：

您提出的设计将起作用，但使用常规函数指针将大大限制您可以注册的回调类型，虽然更强大，但基于从固定接口继承的方法更冗长，需要客户端做更多工作才能定义回调。

在这个答案中，我将首先展示一些如何std::function用于此目的的示例。这些示例几乎不言自明，展示了与std::function您概述的解决方案相比，使用如何以及为什么会带来优势。

但是，基于 的幼稚方法std::function也有其自身的局限性，我将列出这些。这就是为什么我最终建议你看看Boost.Signals2：它是一个非常强大且易于使用的库。我将在这个答案的最后提到 Boost.Signals2。希望了解基于std::functionfirst 的简单设计将使您以后更容易掌握信号和插槽的更复杂方面。

基于 std::function<> 的解决方案

让我们介绍几个简单的类，并为一些具体示例打下基础。这里，anorder是具有 anid并且包含多个items 的东西。每个item都由 a 描述type（为简单起见，这里它可以是书或 dvd）和 a name：

#include <vector>
#include <memory>
#include <string>

struct item // A very simple data structure for modeling order items
{
    enum type { book, dvd };

    item(type t, std::string const& s) : itemType(t), name(s) { }
    
    type itemType; // The type of the item

    std::string name; // The name of the item
};

struct order // An order has an ID and contains a certain number of items
{
    order(int id) : id(id) { }

    int get_id() const { return id; }
    
    std::vector<item> const& get_items() const { return items; }

    void add_item(item::type t, std::string const& n)
    { items.emplace_back(t, n); }

private:

    int id;
    std::vector<item> items;
};

我要概述的解决方案的核心是下面的类order_repository，它的内部用法是std::function保存客户端注册的回调。

回调可以通过register_callback()函数注册，并且（非常直观地）通过unregister_callback()提供注册时返回的 cookie 通过函数取消registered_callback()注册：

该函数具有place_order()下订单的process_order()功能，以及触发处理所有订单的功能。这将导致按顺序调用所有已注册的处理程序。每个处理程序都会收到对同一已下订单向量的引用：

#include <functional>

using order_ptr = std::shared_ptr<order>; // Just a useful type alias

class order_repository // Collects orders and registers processing callbacks
{

public:

    typedef std::function<void(std::vector<order_ptr>&)> order_callback;

    template<typename F>
    size_t register_callback(F&& f)
    { return callbacks.push_back(std::forward<F>(f)); }

    void place_order(order_ptr o)
    { orders.push_back(o); }

    void process_all_orders()
    { for (auto const& cb : callbacks) { cb(orders); } }

private:

    std::vector<order_callback> callbacks;
    std::vector<order_ptr> orders;
};

该解决方案的优势在于使用std::function来实现类型擦除并允许封装任何类型的可调用对象。

下面的帮助函数，我们将使用它来生成和放置一些订单，完成设置（它只是创建四个订单并为每个订单添加一些项目）：

void generate_and_place_orders(order_repository& r)
{
    order_ptr o = std::make_shared<order>(42);
    o->add_item(item::book, "TC++PL, 4th Edition");
    r.place_order(o);

    o = std::make_shared<order>(1729);
    o->add_item(item::book, "TC++PL, 4th Edition");
    o->add_item(item::book, "C++ Concurrency in Action");
    r.place_order(o);

    o = std::make_shared<order>(24);
    o->add_item(item::dvd, "2001: A Space Odyssey");
    r.place_order(o);

    o = std::make_shared<order>(9271);
    o->add_item(item::dvd, "The Big Lebowski");
    o->add_item(item::book, "C++ Concurrency in Action");
    o->add_item(item::book, "TC++PL, 4th Edition");
    r.place_order(o);
}

现在让我们看看我们可以提供哪些类型的回调。首先，让我们有一个打印所有订单的常规回调函数：

void print_all_orders(std::vector<order_ptr>& orders)
{
    std::cout << "Printing all the orders:\n=========================\n";
    for (auto const& o : orders)
    {
        std::cout << "\torder #" << o->get_id() << ": " << std::endl;

        int cnt = 0;
        for (auto const& i : o->get_items())
        {
            std::cout << "\t\titem #" << ++cnt << ": ("
                      << ((i.itemType == item::book) ? "book" : "dvd")
                      << ", " << "\"" << i.name << "\")\n";
        }
    }

    std::cout << "=========================\n\n";
}

还有一个使用它的简单程序：

int main()
{
    order_repository r;
    generate_and_place_orders(r);

    // Register a regular function as a callback...
    r.register_callback(print_all_orders);

    // Process the order! (Will invoke all the registered callbacks)
    r.process_all_orders();
}

这是显示该程序输出的实时示例。

相当合理的是，您不仅限于注册常规函数：任何可调用对象都可以注册为回调，包括保存一些状态信息的函子。让我们将上面的函数重写为一个仿函数，它可以打印与上面函数相同的详细订单列表print_all_orders()，或者不包括订单项目的简短摘要：

struct print_all_orders
{
    print_all_orders(bool detailed) : printDetails(detailed) { }
    
    void operator () (std::vector<order_ptr>& orders)
    {
        std::cout << "Printing all the orders:\n=========================\n";
        for (auto const& o : orders)
        {
            std::cout << "\torder #" << o->get_id();
            if (printDetails)
            {
                std::cout << ": " << std::endl;
                int cnt = 0;
                for (auto const& i : o->get_items())
                {
                    std::cout << "\t\titem #" << ++cnt << ": ("
                              << ((i.itemType == item::book) ? "book" : "dvd")
                              << ", " << "\"" << i.name << "\")\n";
                }
            }
            else { std::cout << std::endl; }
        }

        std::cout << "=========================\n\n";
    }
    
private:
    
    bool printDetails;
};

以下是如何在小型测试程序中使用它：

int main()
{
    using namespace std::placeholders;

    order_repository r;
    generate_and_place_orders(r);

    // Register one particular instance of our functor...
    r.register_callback(print_all_orders(false));

    // Register another instance of the same functor...
    r.register_callback(print_all_orders(true));

    r.process_all_orders();
}

这是此实时示例中显示的相应输出。

由于 提供的灵活性std::function，我们还可以将 的结果注册std::bind()为回调。为了用一个例子来证明这一点，让我们再介绍一个类person：

#include <iostream>

struct person
{
   person(std::string n) : name(n) { }

   void receive_order(order_ptr spOrder)
   { std::cout << name << " received order " << spOrder->get_id() << std::endl; }

private:
    
   std::string name;
};

类person有一个成员函数receive_order()。在某个对象上调用receive_order()一个特定对象已交付给该person对象的事实模型。orderperson

我们可以使用上面的类定义来注册一个回调函数，将所有订单分派给一个人（可以在运行时确定！）：

void give_all_orders_to(std::vector<order_ptr>& orders, person& p)
{
    std::cout << "Dispatching orders:\n=========================\n";
    for (auto const& o : orders) { p.receive_order(o); }
    orders.clear();
    std::cout << "=========================\n\n";
}

此时我们可以编写以下程序，注册两个回调：我们之前使用的打印订单的相同函数，以及将订单分派到特定实例的上述函数Person。以下是我们的做法：

int main()
{
    using namespace std::placeholders;

    order_repository r;
    generate_and_place_orders(r);

    person alice("alice");

    r.register_callback(print_all_orders);

    // Register the result of binding a function's argument...
    r.register_callback(std::bind(give_all_orders_to, _1, std::ref(alice)));

    r.process_all_orders();
}

这个程序的输出显示在这个活生生的例子中。

当然，也可以使用lambdas作为回调。下面的程序建立在前面的程序的基础上，演示如何使用 lambda 回调将小订单分派给一个人，将大订单分派给另一个人：

int main()
{
    order_repository r;
    generate_and_place_orders(r);

    person alice("alice");
    person bob("bob");

    r.register_callback(print_all_orders);
    r.register_callback([&] (std::vector<order_ptr>& orders)
    {
        for (auto const& o : orders)
        {
            if (o->get_items().size() < 2) { bob.receive_order(o); }
            else { alice.receive_order(o); }
        }

        orders.clear();
    });
    
    r.process_all_orders();
}

再一次，这个活生生的例子显示了相应的输出。

超越 std::function<> (Boost.Signals2)

上面的设计比较简单，比较灵活，使用方便。但是，它不允许做很多事情：

  • 它不允许轻易冻结和恢复向特定回调分配事件；
  • 它不会将相关回调集封装到事件 类中；
  • 它不允许对回调进行分组和排序；
  • 它不允许回调返回值；
  • 它不允许组合这些返回值。

所有这些功能以及许多其他功能都由成熟的库提供，例如Boost.Signals2，您可能想看看。熟悉了上面的设计，你会更容易理解它是如何工作的。

例如，这是定义信号并注册两个简单回调的方式，并通过调用信号的调用运算符（来自链接的文档页面）来调用它们：

struct Hello
{
    void operator()() const
    {
        std::cout << "Hello";
    }
};

struct World
{
    void operator()() const
    {
        std::cout << ", World!" << std::endl;
    }
};

int main()
{
    boost::signals2::signal<void ()> sig;

    sig.connect(Hello());
    sig.connect(World());

    sig();
}

像往常一样，这里是上述程序的一个活生生的例子。

于 2013-04-05T20:19:13.300 回答
1

您可能想查看std::function，您的向量将如下所示：

std::vector< std::function< void( Order ) > > functions;

但请注意，std::function开销很小。对于实例，删除new：

function.push_back(GiveStupidOrdersToJohn());
于 2013-03-18T17:54:50.353 回答
0

Boost.Signal正好解决您的问题。你应该看看那个。除非你有特殊要求。特别是 boost.signal 和 boost.function 和/或 std::function 使用类型擦除技术。因此，您可以拥有具有指定签名的可调用事物的向量。如果您的实体是普通的 C 函数（如您在示例中所使用的）或一般的函数对象或成员函数，这并不重要。你可以混合所有这些。

于 2013-04-05T20:16:52.387 回答