Question

下面是一个构造函数，用于形成一个均匀的多维数据集网格（cells）并将每个cell的邻居存储在一个向量中。

问题在于，当我在构造函数的末尾放置断点时，neighbors向量中的所有引用都指向具有正确初始化值（b = 5）的有效单元格。但是，当构造函数退出时，neighbors向量内的所有内容都变为未初始化，并指向我认为没有任何内容（b =负无穷大）。但是，cell本身（包含neighbors向量）仍然使用正确的值正确初始化。

当构造函数退出时，neighbors向量的大小也保持正确。由于某种原因，它似乎失去了对细胞的引用。

CellGrid标头文件（为简洁起见，排除方法）

class CellGrid {
public:
    CellGrid();
    CellGrid(int width, int height, int depth);
    ~CellGrid();

    int w;
    int h;
    int d;
    std::vector<std::vector<std::vector<Cell>>> cells;
};

CellGrid构造函数部分从这里开始

for (int i = 0; i < w; i++) {
    for (int j = 0; j < h; j++) {
        for (int k = 0; k < d; k++) {
            cells[i][j][k] = Cell();
            cells[i][j][k].neighbors.reserve(27);
            cells[i][j][k].particles.reserve(8);
        }
    }
}

for (int i = 0; i < w; i++) {
    for (int j = 0; j < h; j++) {
        for (int k = 0; k < d; k++) {
            for (int x = -1; x < 2; x++) {
                for (int y = -1; y < 2; y++) {
                    for (int z = -1; z < 2; z++) {
                        if (i + x >= 0 && i + x < w && j + y >= 0 && j + y < h && k + z >= 0 && k + z < d) {
                            cells[i][j][k].addNeighbor(cells[i + x][j + y][k + z]);
                        }
                    }
                }
            }
        }
    }
}

细胞结构：

struct Cell {
    std::vector<Particle*> particles;
    std::vector<Cell*> neighbors;
    int b = 5;

    void addParticle(Particle &p) {
        particles.push_back(&p);
    }

    void addNeighbor(Cell &c) {
        neighbors.push_back(&c);
    }
};

Answer 1

我挖了your project一段时间才找到问题。虽然由于矢量改变而导致问题暴露为指针变得无效，但它的一步被删除了。代码导致问题，因为您在CellGrid构造函数的末尾复制了整个ParticleSystem。复制时，会创建一个包含所有单元格的新向量，但它们的邻居指针引用从中复制的CellGrid。违规代码：

ParticleSystem::ParticleSystem(float deltaT)   
{    
    this->deltaT = deltaT;    

    // ...a bunch of for loops...

    grid = CellGrid((int)width, (int)height, (int)depth);    
}

你应该做的是在初始化列表中构造grid

ParticleSystem::ParticleSystem(float deltaT)
    : deltaT{deltaT},
    grid(width, height, depth)
{    
    this->deltaT = deltaT;    

    // ...a bunch of for loops...
}

此外，您应该从CellGrid删除复制构造函数和赋值运算符，这样这个问题就不会在其他地方蔓延

class CellGrid {
  public:
    CellGrid();
    CellGrid(int width, int height, int depth);

    CellGrid(const CellGrid&) = delete;
    CellGrid& operator=(const CellGrid&) = delete;
   //...
};

这可以防止问题首先出现。

另一个注意事项是，关于向量的大小调整，CellGrid值构造函数比需要的更复杂

CellGrid::CellGrid(int width, int height, int depth)
    : w{width},
    h{height},
    d{depth},
    cells(width, std::vector<std::vector<Cell>>(height, std::vector<Cell>(depth, Cell())))
{
    for (auto&& row : cells) {
        for (auto&& col : row ) {
            for (auto&& cell : col) {
                cell.neighbors.reserve(27);
                cell.particles.reserve(8);
            }
        }
    }

    for (int i = 0; i < w; i++) {
        for (int j = 0; j < h; j++) {
            for (int k = 0; k < d; k++) {
                for (int x = -1; x < 2; x++) {
                    for (int y = -1; y < 2; y++) {
                        for (int z = -1; z < 2; z++) {
                            if (i + x >= 0 && i + x < w && j + y >= 0 && j + y < h && k + z >= 0 && k + z < d) {
                                cells[i][j][k].addNeighbor(cells[i + x][j + y][k + z]);
                            }
                        }
                    }
                }
            }
        }
    }
}

因为可以从矢量维度推断宽度，高度和深度，我还建议取出变量并添加width()，height()和depth()成员函数来公开维度。

CellGrid可能不应该是默认的可构造的。

Answer 2

除非您在每个级别适当地调整cells，否则以下代码块会导致超出内存访问范围，并导致未定义的行为。

for (int i = 0; i < w; i++) {
    for (int j = 0; j < h; j++) {
        for (int k = 0; k < d; k++) {
            cells[i][j][k] = Cell();
            cells[i][j][k].neighbors.reserve(27);
            cells[i][j][k].particles.reserve(8);
        }
    }
}

您需要的是：

cells.resize(w);
for (int i = 0; i < w; i++) {
    cells[i].resize(h);
    for (int j = 0; j < h; j++) {
        cells[i][k].resize(d);
        for (int k = 0; k < d; k++) {
            // cells[i][j][k] = Cell(); <-- not needed; done by resize()
            cells[i][j][k].neighbors.reserve(27);
            cells[i][j][k].particles.reserve(8);
        }
    }
}

Answer 3

看起来在cells的构造函数中声明了CellGrid，是这样吗？

std::vector<std::vector<std::vector<Cell>>> cells;

这是有问题的，因为cells按值保存所有Cell个类。当cells存在范围时（在构造函数返回时发生，cells变量被破坏，导致其向量（和嵌套向量，因此Cell结构）的内容被破坏因此，指向Cell对象的指针无效，取消引用它们会导致未定义的行为。

相反，将cells设为CellGrid的私有成员变量，这样做会使cells（以及各个Cell结构）的范围保持活动，直到{ {1}}本身就被破坏了。

当构造函数退出时，指针会丢失引用

3 个答案: