Question

我确信之前已经问过这个问题，但是这个问题的术语令人困惑，而且我是新的顶级C ++我甚至不确定我是否正确使用它，所以我无法找到它以前问过。如果我错过了，请原谅我。

（如果有人足够专家在问题中纠正我的语法，请这样做，以便将来我可能更准确;-)）

我需要定义一个类，其中成员数组存储指向所述类的所有实例的指针。数组由每个成员都有的整数id索引。

因此可以访问：

MyClass testcase = MyClass();
int i = testcase.id;
MyClass* tempVar;
tempVar = MyClass::InstanceRecord[i]; // this is the procedure in ?

应该使用指向新创建的类“testcase”实例的指针填充tempVar。通过这种方式，班级成员可以通过他们的“id”成员互相引用。

我的问题在于声明数组'InstanceRecord'。我无法控制数组的填充顺序（换句话说，创建了类的实例），并且id编号是预定义的[段落编辑]。因此我需要使用以下形式:(注意：这是在类定义中）

static MyClass* InstanceRecord[MAXIMUM_POSSIBLE_INSTANCES] = {x};

为了声明数组，并在一个步骤中填充数组的整个宽度。这样我就可以在调用MyClass（）（构造函数）的过程中改变数组给定元素的值。

问题是我不知道如何使用尚不存在的内存指针填充数组。请有人在我之前的陈述中向我解释我的'='的权利，或者给出另一种方法吗？

编辑：类定义如下所示：

class MyClass{
  Public:
    MyClass(string fileName){

      // Initialize class members from file data
      // including the id member

      // list of other members which require a status of True
      // before this item has an available of True.  id1-id5
      // represent id members of other instances of this class.
      // these id's all come from hard files.
      required_data[] = {id1, id2, id3, id4,id5};
      available=0; //boolean false
      status=0; //boolean false

      // is this the right way to do a vector of pointers?
      InstanceRecord[id]= this;
    }

    MyClass* get_instance_by_id(int i){
      return InstanceRecord[i];
    }

    bool is_available(){
      return available;
    }

    void update_available(){
      int sum = 0;
      for (int i = 0; i<5 ;i++){
        if (InstanceRecord[required_data[i]].status == 1 || required_data[i] == 0){
          sum +=1;
        }
      }
      if (sum >=5){
        available = 1;
      }
    }

  Private:
    int id;
    std::vector<MyClass*>InstanceRecord (MAX_INSTANCES, nullptr);
    int required_data[5];
    bool status;
    bool available;
}

编辑：一个示例数据文件（通常不允许注释，但为了清晰起见而添加注释）

Widget Glue Removal Tool  // becomes MyClass.name
1251                      // becomes MyClass.id
...lots of other stuff... // becomes MyClass.[some_var_name]
14,37,1841,15,27          // becomes the id1...id5 which must be
                          // status checked to determine this
                          // object's available flag.  These ints
                          // are the id's (like this 1251) of those
                          // other instances.

这个数据实际上是我的宠物项目，这是一个视频游戏。该类表示“研究树”中的项目，其中必须在新主题可用之前完成必要的研究。树和主题不一定是线性的。在获得对项目47的访问权之前，您可能必须研究项目20,400,12和15（因此，其ID为20,400,12和15的实例都必须具有状态= 1，表明在项目47可用之前它们已完成= 1在研究项目选择窗口中显示它）。由于研究树是通过读取目录中的每个文件来填充的，因此在非受控序列中，我需要在创建类的第一个实例时使用某种空指针（当前假设为nullptr）填充我的索引向量。我原来的问题是，并且基本上仍然是如何用这些数据填充向量。我现在知道了

std::vector<MyClass*>InstanceRecord(MAX_POSSIBLE_INSTANCES, X);

应该满足我的需求，但是可以nullptr替换这行中的X吗？

巴里的答案中的工厂课实际上教会了我很多，但下一个答案似乎更适合我的需要。在这一点上，我只是想确定Michaels的答案是否可以简单地修改为：

id=<data read in from file>;
InstanceRecord[id]=this;

他的第五和第六行答案。

正如我所说的那样，我只是在C ++中喋喋不休，显然我缺乏对术语的正确理解，因此无法很好地陈述问题，这导致了一些混乱。编译时间来编译这将是巨大的，所以我希望在我开始这个过程之前尽可能地让它几乎没有bug（不是我们所有人）。

Answer 1

我认为你想要的是一个对象工厂：

template <typename T>
class Factory {
private:
    static std::vector<std::unique_ptr<T>> instances;

public:
    static T* create() {
        std::unique_ptr<T> obj{new T};
        obj->id = instances.size();
        instances.emplace_back(std::move(obj));
        return instances.back().get();
    }

    static T* get(size_t idx) const {
        return instances[idx].get(); 
    }
};

用作：

MyClass* testcase = Factory<MyClass>::create();
assert(testcase->id == 0);
assert(Factory<MyClass>::get(0) == testcase);

Answer 2

您可以通过将跟踪向量添加为静态实例来完成此操作。您还需要在销毁时从跟踪向量中删除该项。如果您正在从多个线程创建/更新，则需要将其锁定/解锁。

如果没有锁定，它可能看起来有点像这样。

class MyClass{
  Public:
    MyClass(string fileName){  
      status=0;
      id = instanceRecord.size();
      instanceRecord.push_back(this);          
    }

   ~MyClass() {
      //Clear it so that we dont access invalid data in update_available.
      instanceRecord[id]=NULL;
   }

    static MyClass* get_instance_by_id(int i){
      //TODO: Add bounds checking here.
      return instanceRecord.get(i);
    }    

    void update_available(){
      int sum = 0;
      for (int i = 0; i<5 ;i++){
        MyClass * instance = instanceRecord[i];
        if(instance==NULL)
          continue;  
        if (instanceRecord[required_data[i]].status == 1 || required_data[i] == 0){
          sum +=1;
        }
      }
      if (sum >=5){
        available = 1;
      }
    }

  private:
    int id;
    static std::vector<MyClass*>instanceRecord;
    ...
}

然后你需要添加一个添加静态向量的.cpp文件 - 就像这样。

std::vector<MyClass> MyClass::instanceRecord = std::vector<MyClass>();

如果你需要锁定，那么你需要添加一个静态锁对象，并用该锁包装对instanceRecord的所有访问。

最后一个附带条件是，如果你在主要的MyClass之外创建任何实例，由于使用静态变量，你可能会遇到"static initialization order fiasco"。使用某些单例方法可以解决这个问题，但它们使事情看起来更复杂，所以在简单的情况下不值得。

将所有类实例的列表存储为类中的静态数组

2 个答案: