✔ [C++]Manche Werte in Array sind in Ordnung und manche wiederum nicht

[FBIagent]

Guten tag,

ich habe im Momment ein Problem mit einem Falschpointer.
Ich habe eine Liste mit fester Größe, die eine 2DMap representieren soll.
Mit den X und Y coordinaten errechne ich den Offset um das richtige Node
aus der liste zu bekommen. Dabei bekomme ich leider einen Falschpointer
zurückgeliefert.

#include <iostream>

#define OFFSET_OF(X, Y, DIMENSION_X) (Y * DIMENSION_X + X)
#define ABS(N) (N < 0 ? -N : N)
#define CALC_H(CUR_NODE, END_NODE) ((ABS(CUR_NODE->GetX() - END_NODE->GetX()) * 10) + (ABS(CUR_NODE->GetY() - END_NODE->GetY()) * 10))

enum PathNodeState
{
    UNTOUCHED,
    OPEN,
    CLOSED
};

class PathNode
{
public:
    PathNode()
    : m_X(0), m_Y(0), m_Parent(NULL), m_IsWalkable(true), m_State(UNTOUCHED), m_F(0), m_G(0), m_H(0)
    {}

    void SetCoords(int X, int Y)
    {
        m_X = X;
        m_Y = Y;
    }

    void SetParent(PathNode *Parent)
    {
        m_Parent = Parent;
    }

    void SetIsWalkable(bool IsWalkable)
    {
        m_IsWalkable = IsWalkable;
    }

    void SetState(PathNodeState State)
    {
        m_State = State;
    }
    
    void SetPathScore(int G, int H)
    {
        m_G = G;
        m_H = H;
        m_F = m_G + m_H;
    }

    int GetX()
    {
        return m_X;
    }
    
    int GetY()
    {
        return m_Y;
    }

    PathNode *GetParent()
    {
        return m_Parent;
    }

    bool IsWalkable()
    {
        return m_IsWalkable;
    }
    
    PathNodeState GetState()
    {
        return m_State;
    }

    int GetF()
    {
        return m_F;
    }
    
    int GetG()
    {
        return m_G;
    }

    int GetH()
    {
        return m_H;
    }

    bool operator==(PathNode *Node)
    {
        return Node->GetX() == m_X && Node->GetY() == m_Y;
    }
private:
    int m_X;
    int m_Y;
    PathNode *m_Parent;
    bool m_IsWalkable;
    PathNodeState m_State;
    int m_F;
    int m_G;
    int m_H;
};

class AStarPath
{
public:
/*    AStartPath(PathNode **Map, int AreaDimensionX, int AreaDimensionY)
    : m_Map(Map), m_AreaDimensionX(AreaDimensionX), m_AreaDimensionY(AreaDimensionY)
    {
    }*/
    AStarPath()
    {
        CreateExampleMap();
    }

    PathNodeList *FindPath(int StartX, int StartY, int EndX, int EndY)
    {
        PathNode *StartNode = m_Map[OFFSET_OF(StartX, StartY, m_AreaDimensionX)];
        PathNode *EndNode = m_Map[OFFSET_OF(EndX, EndY, m_AreaDimensionX)];
        PathNode *CurrentNode = StartNode;
        PathNodeList *NodeList = new PathNodeList(m_AreaDimensionX, m_AreaDimensionY);

        while (true)
        {
            if (CurrentNode == EndNode)
            {
                NodeList->Add(CurrentNode);

                std::cout << "Path found :)" << std::endl;
                std::cout << "m_OpenList with " << m_OpenList->GetSize() << " elements left." << std::endl;
                std::cout << "m_ClosedList with " << m_ClosedList->GetSize() << " elements." << std::endl;

                /*
                 * Trace Path:
                 * Start from EndNode.
                 * Stop when we reach StartNode.
                 * NodeList will contain the path including start and end node.
                 */
                PathNode *LastNode = EndNode;

                while (LastNode != StartNode)
                {
                    PathNode *ParentNode = LastNode->GetParent();
                    NodeList->Add(ParentNode);
                    LastNode = ParentNode;
                }

                return NodeList;
            }

            PathNode *CheckNode = NULL;
            
            if (CurrentNode->GetX() > 0 && CurrentNode->GetY() > 0)
            {
                CheckNode = m_Map[OFFSET_OF(CurrentNode->GetX() - 1, CurrentNode->GetY() - 1, m_AreaDimensionX)];

                if (CheckNode->IsWalkable() &&
                    m_Map[OFFSET_OF(CurrentNode->GetX() - 1, CurrentNode->GetY(), m_AreaDimensionX)]->IsWalkable() &&
                    m_Map[OFFSET_OF(CurrentNode->GetX(), CurrentNode->GetY() - 1, m_AreaDimensionX)]->IsWalkable())
                {
.........................
private:
	int m_AreaDimensionX;
	int m_AreaDimensionY;
	PathNode **m_Map;
	PathNodeList *m_OpenList;
	/*
	 * Do we really need the list for closed nodes?
	 * Maybe remove it, we have PathNodeState(UNTOUCHED or OPEN or CLOSED) in each PathNode
	 * and we don't use the closed list expect for adding closed PathNodes
	 */
	PathNodeList *m_ClosedList;

	/*
	 * Initializes members for testing
	 */
	void CreateExampleMap()
	{
		m_AreaDimensionX = 7;
		m_AreaDimensionY = 5;
		m_Map = new PathNode*[m_AreaDimensionX * m_AreaDimensionY];
		m_OpenList = new PathNodeList(m_AreaDimensionX, m_AreaDimensionY);
		m_ClosedList = new PathNodeList(m_AreaDimensionX, m_AreaDimensionY);

		for (unsigned int x=0;x<m_AreaDimensionX;++x)
		{
			for (unsigned int y=0;y<m_AreaDimensionY;++y)
			{
				int Offset = OFFSET_OF(x, y, m_AreaDimensionX);

				m_Map[Offset] = new PathNode;
				m_Map[Offset]->SetCoords(x, y);
			}
		}

		m_Map[OFFSET_OF(4, 1, m_AreaDimensionX)]->SetIsWalkable(false);
		m_Map[OFFSET_OF(4, 2, m_AreaDimensionX)]->SetIsWalkable(false);
		m_Map[OFFSET_OF(4, 3, m_AreaDimensionX)]->SetIsWalkable(false);
	}
};

int main(int argc, char *argv[])
{
	AStarPath Pathfind;
	Pathfind.FindPath(2, 2, 6, 2);
}

Es geht um
CheckNode = m_Map[OFFSET_OF(CurrentNode->GetX() - 1, CurrentNode->GetY() - 1, m_AreaDimensionX)];

Dies scheint mir einen falschen Pointer zurückzuliefern, StartNode und EndNode sind
laut Debugger in ordnung und deren member haben auch die erwarteten Werte.
Der Debugger sagt mir access violation in der Methode PathNode::IsWalkable()
von CheckNode.

Best wisches
FBIagent

 

[deepthroat]

Hi.

Makros sind toll - man sollte sie allerdings äußerst sparsam und mit Bedacht einsetzen. ;-]

Z.B. dein ABS Makro ist problematisch weil dort der Parameter mehrfach ausgewertet wird. Warum nimmst du nicht einfach abs() aus cmath?

Dein OFFSET_OF Makroaufruf für

CheckNode = m_Map[OFFSET_OF(CurrentNode->GetX() - 1, CurrentNode->GetY() - 1, m_AreaDimensionX)];

wird expandiert zu:

CheckNode = m_Map[(CurrentNode->GetY() - 1 * m_AreaDimensionX + CurrentNode->GetX() - 1)];

Ich denke mal du siehst was falsch ist (Tipp: Punktrechnung geht vor Strichrechnung)

Gruß

 

[FBIagent]

Ja das hats gebracht, danke.

Mal wieder was dazu gelernt