Segmentation fault, Debugger i dziwne zachowania.

Question

Dzień dobry!

Od kilku tygodni "Użeram" się z pewnym programem. Miał on za zadania wygenerować mapę na układzie współrzędnych kartezjański. Nie jest to ważne. Najistotniejsze jest to, że używa on bardzo często szybkiej alokacji i zwalniania pamięci. Program jest podzielony na ok. 7 plików, które nie służą tylko w celu generowania tej mapy. Znajomość tego kodu nie jest potrzebna (Najprawdopodobniej) do odpowiedzi na moje pytanie. Uwaga: w kodzie została użyta nie deklarowana wcześniej klasa szablonowa Vector<type> z typdefem Vector2i jest to klasa posiadająca po prostu dwie zmienne x i y typu całkowitego. Wyślę główne segmenty:

//GŁÓWNY PLIK GENERATORA
#ifndef MAP_H_INCLUDED
#define MAP_H_INCLUDED

#include "Room.h"
#include <time.h>

class Map
{
public:
    Room * rooms;

    void generateMap(unsigned short roomsNumber)
    {
        std::cout << "Prakwiecie" << std::endl;
        if(rooms)
            delete rooms;
        rooms = new Room[roomsNumber];
        rooms[0].setCoordinates(0, 0);

        std::cout << "Poprakwiecie" << std::endl;

        unsigned int * roomsToGenerate = new unsigned int[1];
        unsigned short numOfRoomsToGen = 1;
        roomsToGenerate[0] = 0;

        unsigned int id = 0;

        while(id < roomsNumber - 1)
        {
            unsigned int wasRoom;
            unsigned int crashShield;
            wasRoom = 0;
            crashShield = 0;

            SideVector possibleWays;
            possibleWays = checkNearby(rooms, roomsNumber, rooms[roomsToGenerate[0]]);

            std::cout << "Zakwiecie" << std::endl;

            do
            {
                std::cout << "Zasrokwiecie" << std::endl;
                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Up && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, -1), Side::Down))
                if(id < roomsNumber - 1 && !possibleWays.Up && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, -1), Side::Down))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Up);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Down);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x, rooms[roomsToGenerate[0]].coordinates.y - 1);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    id++;
                    wasRoom++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }

                std::cout << "Srodkwiecie" << std::endl;

                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Down && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, 1), Side::Up))
                if(id < roomsNumber - 1 && !possibleWays.Down && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, 1), Side::Up))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Down);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Up);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x, rooms[roomsToGenerate[0]].coordinates.y + 1);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    id++;
                    wasRoom++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }

                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Right && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(1, 0), Side::Left))
                if(id < roomsNumber - 1 && !possibleWays.Right && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(1, 0), Side::Left))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Right);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Left);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x + 1, rooms[roomsToGenerate[0]].coordinates.y);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    wasRoom++;
                    id++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }
                std::cout << "Drusrukwiecie" << std::endl;

                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Left && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(-1, 0), Side::Right))
                if(id < roomsNumber - 1 && !possibleWays.Left && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(-1, 0), Side::Right))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Left);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Right);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x - 1, rooms[roomsToGenerate[0]].coordinates.y);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    wasRoom++;
                    id++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }

                crashShield++;
                std::cout << "lol" << std::endl;
            }
            while(!wasRoom && crashShield < 10 && id < roomsNumber - 1);

                delFirst(&roomsToGenerate, numOfRoomsToGen);
                numOfRoomsToGen--;

                std::cout << "Kwiecie" << std::endl;
        }
        std::cout << "Pokwiecie" << std::endl;
        return;
    }

    ~Map()
    {
        delete rooms;
    }
};

#endif // MAP_H_INCLUDED

//PLIK POKOJU
#ifndef ROOM_H_INCLUDED
#define ROOM_H_INCLUDED

#include "Door.h"

class Room
{
public:

    Door * doors;
    unsigned int doorsNumber = 0;
    Vector2i coordinates;

    Room() :coordinates(0, 0) {}

    Room(Door * cDoors, unsigned int cDorNum, Vector2i cCor) :coordinates(cCor), doorsNumber(cDorNum)
    {
        delete doors;
        doors = cDoors;
    }

    void addDoor(Room * fRoom, Side fSide)
    {
        Door * bDoors = new Door[doorsNumber + 1];

        for(unsigned int i = 0; i < doorsNumber; i++)
            bDoors[i] = doors[i];

        bDoors[doorsNumber] = Door(fRoom, fSide);
        delete doors;
        doors = bDoors;
        doorsNumber++;
    }

    void setCoordinates(int x, int y)
    {
        coordinates = Vector2i(x, y);
    }

    ~Room()
    {
        delete doors;
    }
};

bool isPosFree(Room fRoomsArray[], unsigned int fArrayLength, Vector2i fCoordinates)
{
    for(int i = 0; i < fArrayLength; i++)
        if(fRoomsArray[i].coordinates.x == fCoordinates.x && fRoomsArray[i].coordinates.y == fCoordinates.y)
            return false;

    return true;
}

bool isDoorOnSide(Door fDoorArray[], unsigned int fDoorsNumber, Side fSide)
{
    for(int i = 0; i < fDoorsNumber; i++)
        if(fDoorArray[i].doorsSide == fSide)
            return true;

    return false;
}

SideVector checkNearby(Room fRoomsArray[], unsigned int fArrayLength, Room fRoom)
{
    SideVector sides;

    for(int i = 0; i < fArrayLength; i++)
    {
            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i( -1, 0))))
                sides.Up = true;

            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i(1, 0))))
                sides.Down = true;

            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i(0, 1))))
                sides.Right = true;

            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i(0, -1))))
                sides.Left = true;

        return sides;
    }
}

bool isNotColliding(Room fRoomsArray[], unsigned int fArrayLength, Vector2i cCor, Side exSide)
{
    bool Colliding = false;

    for(int i = 0; i < fArrayLength; i++)
    {
        if(exSide != Side::Up)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(0, -1))))
                Colliding = true;

        if(exSide != Side::Down)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(0, 1))))
                Colliding = true;

        if(exSide != Side::Right)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(1, 0))))
                Colliding = true;

        if(exSide != Side::Left)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(-1, 0))))
                Colliding = true;

        return Colliding;
    }
}

#endif // ROOM_H_INCLUDED

//PLIK DRZWI
#ifndef DOOR_H_INCLUDED
#define DOOR_H_INCLUDED

#include "Room.h"
#include "SC.h"

class Room;

class Door
{
public:
    Room * goalRoom;
    Side doorsSide;

    Door(Room * cGoalRoom, Side cDoorsSide) :goalRoom(cGoalRoom), doorsSide(cDoorsSide) {}
    Door() {}

    Room * getGoalRoom()
    {
        return goalRoom;
    }

    Room * getRoom()
    {
        return goalRoom;
    }
};

#endif // DOOR_H_INCLUDED

//KLASY I FUNKCJE POMOCNICZE
#ifndef SC_H_INCLUDED
#define SC_H_INCLUDED

#include "SfmlBase.h"
#include <ios>


enum Corner
{
    UR,
    UL,
    DR,
    DL,
};

enum Direction
{
    Left, Right, Up, Down
};

struct MovementDirection
{
    bool    Up = 0,
            Down = 0,
            Right = 0,
            Left = 0;
};

typedef Direction Side;
typedef MovementDirection SideVector;

std::ostream & operator<<(std::ostream & fStr, SideVector fVec)
{
    fStr << "Up = "     << std::boolalpha  << fVec.Up    << std::endl;
    fStr << "Down = "   << std::boolalpha  << fVec.Down  << std::endl;
    fStr << "Right = "  << std::boolalpha  << fVec.Right << std::endl;
    fStr << "Left = "   << std::boolalpha  << fVec.Left  << std::endl;
    return fStr;
}

std::ostream & operator <<(std::ostream & buffi, Vector2i coordinates)
{
    buffi << "(";
    buffi << coordinates.x;
    buffi << ", ";
    buffi << coordinates.y;
    buffi << ")";

    return buffi;
}

template<class type>
void delFirst(type ** tab, unsigned short length)
{
    type * newTab = new type[length - 1];
    newTab = *tab + 1;
    *tab = newTab;
}

template<class type>
void addNew(type ** tab, unsigned short length, type added)
{
    type * newTab = new type[length + 1];
    newTab = *tab;
    newTab[length] = added;
    *tab = newTab;
}

#endif // SC_H_INCLUDED

//krótki plik. trochę nie ma sensu
#ifndef SFMLBASE_H_INCLUDED
#define SFMLBASE_H_INCLUDED

#include <SFML/Graphics.hpp>
#include <iostream>

using namespace sf;

#endif

Problem jest taki, że gdy uruchamiam program samodzielnie zacina się po ok. 14 lub mniej rekurencjach w pliku z mapą, lecz kiedy uruchamiam go debuggerem to wtedy wykonuje się tyle razy ile sobie zażyczę, zwracając jedynie przy zamykaniu programu błąd "Segmentation fault". Jest to dla mnie co najmniej dziwne więc proszę o pomoc.

Comments

W jakim środowisku to kompilujesz,debuggujesz? Jak dokładnie wygląda ten "segmentation fault"?

---

Code Blocks 17.12,

Answer 1

delFirst i addNew są źle napisane. Tak powinno być:

template<class type>
void delFirst(type ** tab, unsigned short length)
{
    type * newTab = new type[length - 1];
	std::copy_n(*tab + 1, length - 1, newTab);
    delete[] *tab;
	*tab = newTab;
}
 
template<class type>
void addNew(type ** tab, unsigned short length, type &&added)
{
    type * newTab = new type[length + 1];
	std::copy_n(*tab, length, newTab);
    newTab[length] = std::forward<type>(added);
    delete[] *tab;
    *tab = newTab;
}

To nie jest najefektywniejsza metoda zwiększania/zmniejszania tablic. Użyj std::deque.

 

Klasa Room musi mieć zaimplementowaną Rule of three/five.

 

Do usuwania tablic powinieneś użyć delete[]. Samo delete może powodować wycieki pamięci.