C++ 继承问题

我把事情搞砸了。 代码如下：

#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;
}

#包括
类连接{
私人：
std：：字符串数据；
无效（*saveCallBack)（）；
公众：
连接c（std:：string&data）：数据{std:：cout如果我理解正确（你想从一个连接[object]调用几个回调），你需要在连接c中有一个列表来注册回调（就像c中的委托一样，如果你知道的话）。

如果此连接发生事件，它必须知道报告的位置。因此，您必须以某种方式迭代回调（逐个调用；不能一次调用所有回调）。最简单、直接的方法是使用STL列表，或者boost提供适当的功能。

请看以下内容：。在主函数中，定义了一个接受多个回调的向量。您可以在connection_c类中使用此模式来添加回调，而不是设置回调。
您的代码为每个实例创建连接对象的副本。然后，只有
组才能访问原始连接对象>.这是您想要的吗？如果不是，您需要更改：

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

开始时尽量保持简单。以后总会有机会改进设计。下面是一些示例代码，下面是我在构建时考虑的几件事情：

1） 如前所述，保持简单。例如，可能组概念可以是一个向量（即inst_group_t）开始。随着对设计的了解，您可以在以后不断扩展设计

2） 尝试减少类依赖关系。例如，可能我不需要将连接作为成员变量。我可以在需要时传递它（即执行（））。可能回调不需要注册（即执行（）），因为它与多个inst_c实例的1连接为每个inst_c注册回调意味着该连接将有一些容器。请保持简单：）

3） 尽量使用const和reference（即连接构造函数）。将创建较少的复制构造函数/temp对象

#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;
}

#包括
类连接{
私人：
std：：字符串数据；
公众：
连接（const std:：string&data）：数据（data）{
std：：难道我不明白吗？你没有定义继承关系。+1。那么其中的实际问题是什么？你可以补充一点：不要使用回调，它们是邪恶的（当用作指针时）。请改用继承或模板。我看不出这里有任何回调的理由。此外，向量版本不是很OOP imho。是的，它很简单，但不直观。您必须始终关注向量，每次使用execute时都要进行迭代。包装此类型的imho将非常简单和充分。@DyP-肯定可以包装向量。特别是因为它包含指针。具有RAII模式的类将很好地帮助清理。不确定在这种情况下回调的用途，但回调在这个世界上肯定有一席之地。
#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;
}