Question

有3个结构X，Y和Z

struct Z{
    Z();
    ~Z();
    int c;
}

struct Y{
    Y();
    ~Y();
    int b;
    std::vector<Z> vec_Z;
}

struct X {
    X();
    ~X();
    int a;
    std::vector<Y> vec_Y;
};

并且存在无限循环

while(1) {
    std::vector<X> vec_X;
    // stuff
}

根据// stuff的结果，程序会创建一些X的实例，并将它们推回到向量vec_X中。然后，下一次迭代// stuff确定是否需要创建更多X实例，更新现有实例，并删除不再需要的实例。

实际上，情况比这更复杂。 while循环的每次迭代都将生成X s的向量，x的每个实例X将生成Y s的向量（与x），y的每个实例Y将生成Z（与y相关联）的向量，以及z的每个实例Z将保证一些计算。

while(1) {
    std::vector<X> vec_X;
    // determine how many X's to create/update/delete, then iterate over them

    for(auto x: vec_X){
        std::vector<Y> vec_Y = x.vec_Y;
        // determine how many Y's to create/update/delete, then iterate over them

        for(auto y: vec_Y){
            std::vector<Z> vec_Z = y.vec_Z;
            // determine how many Z's to create/update/delete, then iterate over them

            for(auto z: vec_Z){
                // do stuff
            }

        }

    }


}

需要在循环的每次迭代中确定要创建/更新/删除的精确数X s，Y和Z;仍然，vec_X.size()永远不会超过12，vec_Y.size()永远不会超过10，vec_Z.size()永远不会超过5.容器不需要std::vector，因为元素没有秩序的概念。

问题：

每次循环超出范围时，所有实例都将被删除，每次迭代都会重新创建。如果事情能够超越范围？
如何实施“创建/更新/删除”的想法？
X，Y和Z的所有实例都应具有“非本地意识”，这意味着他们应该能够看到彼此内部的状态。怎么样？我试图通过继承实现这一点，但它让我陷入了一个圆形的地狱。

我目前的代码不够优雅，而且很快变得无法管理。是否有一种简单/自然的方式来实现它？

此外，这是一个最小的工作示例。

#include <iostream>
#include <vector>
#include <unistd.h>
#include <cstdlib>
#include <ctime>

using std::cout;
using std::vector;
using std::string;

struct Z{
    Z(){}
    ~Z(){}
    int c;
};
struct Y{
    Y(){}
    ~Y(){}
    int b;
    uint number_of_Z;
    vector<Z> vec_Z;
};
struct X{
    X(){}
    ~X(){}
    int a;
    uint number_of_Y;
    vector<Y> vec_Y;
};

int main(){
    srand(time(NULL));
    auto epoch = 0ULL;
    uint number_of_X;

    while(1){
        vector<X> vec_X;
        number_of_X = 1 + rand()%3;  // Determine this programatically, each loop
        cout << string(79, '-') <<"\n" << "EPOCH " << epoch <<"\n";

        // Initialize each instance of X programatically
        for(auto i=0; i<number_of_X; i++){
            X x;
            x.a = rand()%10;
            x.number_of_Y = 1 + rand()%3;  // Determine this programatically, each loop

            // Initialize each instance of Y programatically
            for(auto j=0; j<x.number_of_Y; j++){
                Y y;
                y.b = rand()%10;
                y.number_of_Z = 1 + rand()%3;  // Determine this programatically, each loop

                // Initialize each instance of Z programatically
                for(auto k=0; k<y.number_of_Z; k++){
                    Z z;
                    z.c = rand()%10;

                    y.vec_Z.push_back(z);

                }
                x.vec_Y.push_back(y);

            }
            vec_X.push_back(x);

        }

        // Iterate through everything
        for(auto x: vec_X){
            cout << "x.a " << x.a <<"\n";
            // ... do stuff with the elements of `x`, in this case x.a

            for(auto y: x.vec_Y){
                cout << "  y.b " << y.b <<"\n";
                // ... do stuff with the elements of `y`, in this case y.b

                for(auto z: y.vec_Z){
                    cout << "    z.c " << z.c <<"\n";
                    // ... do stuff with the elements of `z`, in this case z.c
                }
            }
        }

        epoch++;
        puts("");
        usleep(2000000);
    }
    return 0;
}

Answer 1

我不确定我是否理解这个问题，但我会尝试回答：

关于所有被删除的实例。您可以暂时保留vector<X> vec_X;。
你的第二个问题很不清楚，你的意思是什么？
如果你想让x，y，z访问其他成员，你可以添加公共功能（Getters）或者通过这种方式制作x，y，z朋友，他们将能够访问私人成员。

如果您要澄清问题2，我会尝试回答。

在嵌套循环期间创建结构并在每次迭代时更新它们

1 个答案: