C++ 动态数组和指针

Question

好的，所以我要做的是创建一个指针数组，这些指针指向大小会发生变化的 vector 。此外，指针数组位于 vector 中的类中。出于某种原因，我似乎遇到了内存损坏的问题。此外，如果我使用 vector ，我会遇到由调整大小和调用构造函数引起的堆栈溢出问题。这是我想要的基本布局。

也许有点草率。但是我最终遇到了内存在 babyclasses 指针中被破坏的问题，基本上我想通过它所连接的 babyclasses 的 babyclasses vector 访问“链接的”babyclasses。这里有什么聪明的想法吗？

在有人告诉我这是一种愚蠢的做事方式之前，这种类型的功能不是面向对象编程的基础吗？

class Baby
{
public:
    deque<shared_ptr<Baby>> vInputs;
    int X;
    int Y;
    int Z;
    Baby()
    {
        numInputs = 0;
        isNull = false;
        wasTickled = false;
        X,Y,Z = 0;

    }
    void addInput(shared_ptr<Baby> baby)
    {
        if(numInputs == 0)
            vInputs = deque<shared_ptr<Baby>>(0);
        vInputs.push_back(baby);
        numInputs++;
    }
    void setXYZ(int x, int y, int z)
    {
        X = x;
        Y = y;
        Z = z;
    }
    void Tickle()
    {
        if(!wasTickled)
            wasTickled = true;
        else
            return;
        for(int i=0;i<numInputs;i++)
        {
            vInputs[i]->Tickle();
        }
    }
    void setNull(bool isnull)
    {
        isNull = isnull;
    }
private:
    int numInputs;
    bool isNull;
    bool wasTickled;
};
class BabyLayer
{
public:
    int Width;
    int Height;
    BabyLayer()
    {
        Width = 0;
        Height = 0;
    }
    BabyLayer(int width, int height)
    {
        Width = width;
        Height = height;
        vecBabies = std::deque<deque<Baby>>(0);
        for(int i=0;i<height;i++)
        {
            deque<Baby> row = deque<Baby>(0);
            for(int i=0;i<width;i++)
            {
                row.push_back(Baby());
            };
            vecBabies.push_back(row);
        }
        MakeConnections();
    }

    Baby * getBaby(int x, int y)
    {
        Baby n = Baby();
        n.setNull(true);
        if(x >= Width || x <0)
            return &n;
        if(y >= Height || y < 0)
            return &n;
        n.setNull(false);
        return &vecBabies[y][x];
    }
    ~BabyLayer(void)
    {

    }
private:
    std::deque<deque<Baby>> vecBabies;
    void MakeConnections()
    {
        for(int y=0;y<Height;y++)
        {
            for(int x=0;x<Width;x++)
            {
                //Top Right
                if(y > 0 && x < Width-1)
                    vecBabies[y][x].addInput(shared_ptr<Baby>(&vecBabies[y-1][x+1]));
                //Middle Right
                if(x < Width -1)
                    vecBabies[y][x].addInput(shared_ptr<Baby>(&vecBabies[y][x+1]));
                //Bottom Right
                if(x < Width -1 && y < Height-1)
                    vecBabies[y][x].addInput(shared_ptr<Baby>(&vecBabies[y+1][x+1]));
                //Bottom Middle
                if(y < Height-1)
                    vecBabies[y][x].addInput(shared_ptr<Baby>(&vecBabies[y+1][x]));
            }
        }
    }
};
class BabyCube
{
public:
    int X;
    int Y;
    int Z;
    BabyCube(int x, int y, int z)
    {
        X = x;
        Y = y;
        Z = z;
        Layers = deque<BabyLayer>();
        for(int i=0;i<z;i++)
        {
            BabyLayer lay = BabyLayer(x,y);
            Layers.push_back(lay);
        }
        NullBaby = Baby();
        NullBaby.setNull(true);
        MakeConnections();
    }
    void MakeConnections()
    {
        int l = Layers.size();
        if(l == 0 || l == 1)
            return;
        for(int layer=0;layer<l;layer++)
        {
            BabyLayer * lay = &Layers[layer];
            if(layer< l-1)
            {
                for(int y=0;y<lay->Height;y++)
                {
                    for(int x=0;x<lay->Width;x++)
                    {
                        //Top Left
                        if(x > 0 && y > 0)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x-1,y-1)));
                        //Top Middle
                        if(y > 0)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x,y-1)));
                        //Top Right
                        if(y > 0 && x+1 < lay->Width-1)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x+1,y-1)));
                        //Middle Right
                        if(x+1 < lay->Width -1)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x+1,y)));
                        //Bottom Right
                        if(x+1 < lay->Width -1 && y+1 < lay->Height-1)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x+1,y+1)));
                        //Bottom Middle
                        if(y+1 < lay->Height-1)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x,y+1)));
                        //Bottom Left
                        if(x > 0 && y+1 < lay->Height-1)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x-1,y+1)));
                        //Middle Left
                        if(x > 0)
                            Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x-1,y)));
                        //Middle Middle
                        Layers[layer].getBaby(x,y)->addInput(shared_ptr<Baby>(Layers[layer+1].getBaby(x,y)));
                    }

                }
            }
        }
    }
    Baby * getBaby(int x, int y, int z)
    {

        if(z >= Layers.size() || z < 0)
            return &NullBaby;
        if(y >= Layers[z].Height || y < 0)
            return &NullBaby;
        if(x >= Layers[z].Width || x < 0)
            return &NullBaby;

        return Layers[z].getBaby(x,y);
    }
    void Update()
    {

    }
    ~BabyCube(void)
    {

    }
private:
    deque<BabyLayer> Layers;
    Baby NullBaby;
};

Answer 1

出于病态的好奇心，我重新审视了这个问题，看看是否有人破译了它。

我在源代码中看到的唯一明显问题是在 BabyLayer::GetBaby() 中:

    Baby n = Baby();
    n.setNull(true);
    if(x >= Width || x <0)
        return &n;             // Bad.
    if(y >= Height || y < 0)
        return &n;             // Bad.

您在堆栈上声明一个新的 Baby 实例，然后返回指向它的指针。名为“n”的 Baby 实例在 GetBaby() 返回时被破坏，返回的指针现在无效。

我不知道您使用的是什么编译器，但 Visual Studio 2010 在这些行上发出“警告 C4172:返回局部变量或临时变量的地址”。请注意，您的代码示例不完整并且实际上没有执行任何操作，我必须声明一个 BabyCube 实例才能收到此警告。

因为我无法破译你的代码应该做什么，也无法理解它的操作，所以我无法解释为什么会抛出内存访问异常。