пытаюсь разобраться

[ya2500]

программу, рисующую кратчайший путь в лабиринте, я написал. работает.

попробую её вылизать и допилить и выложу потом.

[ya2500]

в поисках инфы о динамических массивах набрёл на замечательные уроки по C++:
http://code-live.ru/tag/cpp-manual/

[ya2500]

детально разобравшись в том, что надо исправить, я ничего не исправил(ибо- лень) и выкладываю свою кривую прогу:

    // Maze_Path.cpp: определяет точку входа для консольного приложения.
    //
     
    #include "stdafx.h"
    #include <memory.h> // для memset
     
    int _tmain(int argc, _TCHAR* argv[])
    {  
     
        // *** получаем лабиринт из файла: начало
     
        FILE *file;
        char *input_name= "input.txt", *output_name= "output.txt";
        unsigned char Maze[50][50], c;
     
        // инициализируем массив символами '0'(ноль):
        memset(Maze, '0', sizeof(Maze));
     
        file = fopen(input_name, "r"); // открываем файл для чтения
        // w- write, r- read, a- append
        
        if (file == NULL) return -1;
     
        int x= 0, y= 0; // столбцы и строки
     
        // в последний момент, когда прога была уже почти дописана,
        // я понял, что не знаю координат выхода:
        int x_ext, y_ext;
     
        do {
            c = fgetc(file);
            // fputc, fputs, fgetc, fgets, fprintf, fscanf
            if ((c == '.') || (c == '#'))
            {
                x_ext = x;
                y_ext = y;
                Maze[x][y]= c;
                x++;
            }
            else
                if (c == '\n')
                {
                    y++;
                    x = 0;
                }
        } while (!feof(file));
     
        fclose(file);
     
        // *** получаем лабиринт из файла: конец
     
        // *** описываем класс очередь: начало
     
        class TCoord // координаты на плоскости
        {
        public:
            int x, y;
            TCoord():x(-1),y(-1){}; // по умолчанию задаются координаты (-1,-1)
            TCoord(int a, int b)
            {
                x = a;
                y = b;
            }
        };
     
        struct node // элемент очереди
        {
            TCoord coord; // каждый элемент хранит координаты соответствующего поля лабиринта
            node *next; // и указатель на следующее звено
        };
     
        class TList // список, который и есть сама очередь
        {
        public:
            node *head, *tail; // указатели на начало списка и на конец
            // хочу их видеть публично, чтобы знать, пуста ли очередь
     
            TList():head(NULL), tail(NULL){}; // инициализация указателей как пустых
     
            ~TList() // деструктор для освобождения памяти от всего что будет
            {
                node *temp = head; // временный указатель на начало списка
                while (temp != NULL) // пока в списке что-то есть
                {
                    temp = head->next; // резерв адреса на следующий элемент списка
                    delete head;  // освобождение памяти от первой структуры как элемента списка
                    head = temp;  // сдвиг начала на следующий адрес, который берем из резерва
                }
            }
     
            void add_node(int x, int y) // функция добавления элемента
            {
                node *temp = new node; //Выделение памяти для нового звена списка
                temp->coord.x = x; // временное запоминание принятых параметров
                temp->coord.y = y;
                temp->next = NULL; // следующее звено новосозданной структуры пока пустое
                if (head != NULL) // если список не пуст
                {
                    tail->next = temp; // следующее звено списка это новосозданная структура
                    tail = temp; // и теперь хвост указывает на новое звено
                }
                else
                    head = tail = temp; // если список пуст, добавление первого элемента
            }
     
            TCoord get_node() // функция изъятия элемента из очереди
            {
                TCoord coord;
     
                if (head != NULL)  // если список не пустой
                {
                    coord.x = head->coord.x; // берём данные из начала списка
                    coord.y = head->coord.y;
                    node *temp = head; // обращаемся к началу списка с помощью вспомогательного указателя
                    head = head->next; // сдвиг начала списка
                    delete temp; // освобождение памяти от бывшего звена списка
                }
     
                return coord;
            }
        };
        // !!! можно ли как-то описывать тело функций не в объявлении класса, а где-нибудь потом?
        // !!! у меня это не получилось
     
        // *** описываем класс очередь: конец

[ya2500]

        // *** создаём все нужные структуры: начало
     
        // вспомогательные координаты, изначально- точка входа
        TCoord coord(0,0);
     
        // массив для хранения координат клеток, приближающих к выходу
        TCoord Path[50][50]; // изначально забит координатами (-1,-1)
     
        // создаём очередь и помещаем в неё клетку входа в лабиринт:
        TList list;
        list.add_node( coord.x, coord.y );
     
        // *** создаём все нужные структуры: конец
     
        // *** построение карты путей: начало
     
        do
        {
            // достаём очередную клетку из очереди
            coord = list.get_node();
     
            // находим соседей этой клетки,
            // помеченных в массивах как '.' и (-1,-1) соответственно
            // помечаем их координатой вытащенной из очереди клетки
            // заталкиваем их в очередь
     
            // надо бы обработку соседей запихнуть в функцию,
            // но тогда пришлось бы разбираться с передачей в функцию массивов..
     
            // северный сосед
            if
            (
                (coord.y > 0)&&
                (Maze[coord.x][coord.y-1]   == '.')&&
                (Path[coord.x][coord.y-1].x == -1)&&
                (Path[coord.x][coord.y-1].y == -1)
            )
            {
                Path[coord.x][coord.y-1].x = coord.x;
                Path[coord.x][coord.y-1].y = coord.y;
                
                list.add_node(coord.x, coord.y-1);
            }
     
            // западный сосед
            if
            (
                (coord.x > 0)&&
                (Maze[coord.x-1][coord.y]   == '.')&&
                (Path[coord.x-1][coord.y].x == -1)&&
                (Path[coord.x-1][coord.y].y == -1)
            )
            {
                Path[coord.x-1][coord.y].x = coord.x;
                Path[coord.x-1][coord.y].y = coord.y;
                
                list.add_node(coord.x-1, coord.y);
            }
            
            // южный сосед
            if
            (
                (coord.y < 49)&&
                (Maze[coord.x][coord.y+1]   == '.')&&
                (Path[coord.x][coord.y+1].x == -1)&&
                (Path[coord.x][coord.y+1].y == -1)
            )
            {
                Path[coord.x][coord.y+1].x = coord.x;
                Path[coord.x][coord.y+1].y = coord.y;
                
                list.add_node(coord.x, coord.y+1);
            }
     
            // восточный сосед
            if
            (
                (coord.x < 49)&&
                (Maze[coord.x+1][coord.y]   == '.')&&
                (Path[coord.x+1][coord.y].x == -1)&&
                (Path[coord.x+1][coord.y].y == -1)
            )
            {
                Path[coord.x+1][coord.y].x = coord.x;
                Path[coord.x+1][coord.y].y = coord.y;
                
                list.add_node(coord.x+1, coord.y);
            }
     
        } while (list.head != NULL); // пока очередь не пуста
     
        // *** построение карты путей: конец
     
        // *** построение пути: начало
     
        // двигаемся от выхода ко входу и помечаем *
        TCoord move(x_ext, y_ext);
        
        Maze[move.x][move.y] = '*';
     
     
        do
        {
            coord.x = Path[move.x][move.y].x;
            coord.y = Path[move.x][move.y].y;
     
            move.x = coord.x;
            move.y = coord.y;
     
            Maze[move.x][move.y] = '*';
        }
        while((coord.x != 0)||(coord.y != 0));
     
        // *** построение пути: конец
     
        // *** выводим лабиринт в файл: начало
     
        file = fopen(output_name, "w"); // открываем файл для записи
     
        for (int i=0; i<50; i++)
        {
            for (int j=0; j<50; j++)
            {
                fputc(Maze[j][i],file);
            }
            fputc('\n',file); // перевожу строку
        }  
     
        fclose(file);
     
        // *** выводим лабиринт в файл: конец
     
        // деструкторы, я надеюсь, вызовутся автоматически, по завершении функции _tmain
     
        return 0;
    }