Question

我搞砸了什么。这是代码：

#include <iostream>

class connection_c {
  private:
    std::string data_;
    void (*saveCallBack_)();
  public:
    connection_c(std::string &data) : data_(data) { std::cout << "ctor: " << __FUNCTION__ << ":" << data_ << std::endl;}
    void registerCallBack(void(*cb)()) { saveCallBack_ = cb; }
};

class inst_c {
  private:
    static int id;
    connection_c conn;
    static void cb() { std::cout << __FUNCTION__ << " id = " <<  id << std::endl; } 
  public:
    inst_c(connection_c &c, int a) : conn(c),  id(a)  { 
      std::cout << "ctor: " << __FUNCTION__ << " " << id << std::endl;
      conn.registerCallBack(&cb); 
    }
};

class group_inst_c {
  private:
    connection_c conn;
    inst_c i,j,k;
  public:
    group_inst_c(std::string data) : conn(data), i(conn,1), j(conn,2), k(conn,3) {} 
};


int main() {
  group_inst_c gi("asdf");
  return 0;
}

我想要实现的目标;）

创建一组实例（group_inst_c）
它应初始化组的唯一连接（connection_c）
每个实例（inst_c）都应该使用此连接（它将被序列化）
..另外每个实例都应该注册单独的回调

我肯定搞砸了克隆，但我想可能不仅仅是。有人可以帮我解决这个难题吗？ THX。

Answer 1

您的代码为每个实例创建连接对象的副本。然后，您的group_inst_c只能访问原始连接对象。这是你想要的吗？如果没有，您需要更改：

class inst_c {
  private:
    static int id;
    connection_c& conn; // <-- Needs to be a reference.

此外，每个实例都应该注册单独的回调

我不确定你的意思。回调应该是成员函数吗？然后，您需要使用“指向成员函数的指针”（::*，.*和->*运算符）。如果回调应该是常规函数，那么你应该对你当前的代码没问题。您只需要将其添加到class connection_c：

void doCallback(void) { (*saveCallBack_)(); }

Answer 2

如果我理解正确（你想从单个连接[对象]调用几个回调），你需要在connection_c中有一个列表来注册回调（就像你知道的那样，就像C＃中的代表一样）。
如果此连接发生事件，则必须知道要在何处报告。所以你必须以某种方式迭代回调（逐个调用它们;你不能一次调用它们）。最简单直接的方法是使用STL列表或者提供适当的东西看看这个：A C++ delegate class。在main函数中，定义了一个需要多次回调的向量。您可以在connection_c类中将此模式用于添加，而不是设置回调。

Answer 3

首先尝试保持简单。以后总有机会发展/改进设计。下面是一些示例代码，以下是构建它时我正在考虑的一些事情：

1）如上所述，保持简单。例如，组概念可以是要开始的向量（即inst_group_t）。随着您了解更多信息，您可以随时增加设计。

2）尝试减少类依赖性。例如，我可能不需要将连接作为成员变量。我可以在需要时传递它（即execute（））。也许回调不需要注册（即execute（）），因为它的1个connection_c到许多inst_c实例注册每个inst_c的回调意味着连接会有一些容器。保持简单:)

3）尝试尽可能多地使用const和reference（即connection_c构造函数）。将创建更少的复制构造函数/临时对象。

#include <iostream>

class connection_c {
  private:
    std::string data_;
  public:
    connection_c(const std::string &data) : data_(data) { 
        std::cout << "ctor: " << __FUNCTION__ << ":" << data_ << std::endl;
    }
};

class inst_c {
  private:
    int id;
  public:
    inst_c(int a) : id(a)  { 
      std::cout << "ctor: " << __FUNCTION__ << " " << id << std::endl;
    }

    typedef void (*execute_callback_t)(int i);
    void execute(connection_c& connection, execute_callback_t callback) {
        callback(id);
    }
};

void mycallback(int id) {
    std::cout << "Instance number " << id << " executed" << std::endl;
}

int main() {

    typedef std::vector<inst_c*> inst_group_t;
    inst_group_t group;

    std::string data;
    connection_c connection(data);

    for (int i = 0; i < 10; ++i) 
        group.push_back(new inst_c(i) );

    for (int i = 0; i < 10; ++i) 
        group[i]->execute(connection, mycallback);

    for (int i = 0; i < 10; ++i) 
        delete group[i];

    return 0;
}

继承问题

3 个答案: