Lab3

CMakeLists.txt

@@ -10,9 +10,9 @@ else()
     add_compile_options(-Wall -Wextra -Wpedantic -Wno-gnu-empty-struct -Wno-unused-parameter)
 endif()
 
-add_subdirectory(LibraryC)
+
 add_subdirectory(LibraryCPP)
-add_subdirectory(LibraryCPPClass)
-add_subdirectory(LibraryCPPTemplate)
 
-add_subdirectory(Lab1C)
+
+
+add_subdirectory(Lab3CPP)

Lab3CPP/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_executable(Lab3CPP labb.cpp)
+target_include_directories(Lab3CPP PUBLIC ../LibraryCPP)
+target_link_libraries(Lab3CPP LibraryCPP)
+
+add_test(NAME TestLab3CPP COMMAND Lab3CPP ${CMAKE_CURRENT_SOURCE_DIR}/input.txt ${CMAKE_BINARY_DIR}/output.txt)
+
+
+

Lab3CPP/input.txt

@@ -0,0 +1,5 @@
+######
+#...X#
+#.####
+#...Y#
+######

Lab3CPP/labb.cpp

@@ -0,0 +1,175 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <fstream>
+#include <string>
+using namespace std;
+
+// Тип для лабиринта
+using Maze = vector<string>;
+
+// Функция для обработки соседей
+bool process_neighbors(int x, int y, int nx, int ny, Maze& maze, vector<vector<bool>>& visited, vector<vector<int>>& dist, queue<pair<int, int>>& q, int end_x, int end_y, int dx[], int dy[]) {
+    int n = maze.size();
+    int m = maze[0].size();
+
+    // Проверяем, можно ли двигаться в новую точку
+    if (nx >= 0 && ny >= 0 && nx < n && ny < m && !visited[nx][ny] && maze[nx][ny] != '#') {
+        visited[nx][ny] = true;
+        dist[nx][ny] = dist[x][y] + 1;
+        q.push({ nx, ny });
+
+        // Если достигли цели, восстанавливаем путь
+        if (nx == end_x && ny == end_y) {
+            int cx = end_x, cy = end_y;
+            while (dist[cx][cy] != 0) {
+                maze[cx][cy] = 'x';
+                for (int j = 0; j < 4; ++j) {
+                    int px = cx - dx[j];
+                    int py = cy - dy[j];
+                    if (px >= 0 && py >= 0 && px < n && py < m && dist[px][py] == dist[cx][cy] - 1) {
+                        cx = px;
+                        cy = py;
+                        break;
+                    }
+                }
+            }
+            maze[x][y] = 'X';
+            maze[end_x][end_y] = 'Y';
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// Функция для поиска пути с помощью BFS
+bool bfs(Maze& maze, int start_x, int start_y, int end_x, int end_y) {
+    int n = maze.size();
+    int m = maze[0].size();
+
+    vector<vector<bool>> visited(n, vector<bool>(m, false));
+    vector<vector<int>> dist(n, vector<int>(m, -1));
+
+    queue<pair<int, int>> q;
+    q.push({ start_x, start_y });
+    visited[start_x][start_y] = true;
+    dist[start_x][start_y] = 0;
+
+    int dx[] = { -1, 1, 0, 0 };
+    int dy[] = { 0, 0, -1, 1 };
+
+    while (!q.empty()) {
+        auto [x, y] = q.front();
+        q.pop();
+
+        // Обрабатываем все 4 соседних клетки
+        for (int i = 0; i < 4; ++i) {
+            int nx = x + dx[i];
+            int ny = y + dy[i];
+
+            // Вызываем функцию для обработки соседа
+            if (process_neighbors(x, y, nx, ny, maze, visited, dist, q, end_x, end_y, dx, dy)) {
+                return true; // Путь найден
+            }
+        }
+    }
+
+    return false; // Путь не найден
+}
+
+// Функция для вывода лабиринта в консоль
+void print_maze(const Maze& maze) {
+    for (const auto& row : maze) {
+        cout << row << endl;
+    }
+}
+
+// Функция для чтения лабиринта из файла
+bool read_maze_from_file(const string& filename, Maze& maze, int& start_x, int& start_y, int& end_x, int& end_y) {
+    ifstream input_file(filename);
+    if (!input_file.is_open()) {
+        cerr << "Ошибка при открытии файла: " << filename << endl;
+        return false;
+    }
+
+    string line;
+    maze.clear();
+    int row = 0;
+
+    while (getline(input_file, line)) {
+        maze.push_back(line);
+        for (std::string::size_type col = 0; col < line.size(); ++col) {
+            if (line[col] == 'X') {
+                start_x = row;
+                start_y = col;
+            }
+            if (line[col] == 'Y') {
+                end_x = row;
+                end_y = col;
+            }
+        }
+        row++;
+    }
+
+    input_file.close();
+    return true;
+}
+
+// Функция для записи лабиринта в файл
+bool write_maze_to_file(const string& filename, const Maze& maze) {
+    ofstream output_file(filename);
+    if (!output_file.is_open()) {
+        cerr << "Ошибка при открытии выходного файла: " << filename << endl;
+        return false;
+    }
+
+    for (const auto& row : maze) {
+        output_file << row << endl;
+    }
+
+    output_file.close();
+    return true;
+}
+
+// Основная функция
+int main(int argc, char* argv[]) {
+    if (argc != 3) {
+        cerr << "Использование: " << argv[0] << " <входной файл> <выходной файл>" << endl;
+        return 1;
+    }
+
+    string input_filename = argv[1]; // Имя входного файла
+    string output_filename = argv[2]; // Имя выходного файла
+
+    // Переменные для координат старта и финиша
+    int start_x = -1, start_y = -1, end_x = -1, end_y = -1;
+    Maze maze;
+
+    // Чтение лабиринта из файла
+    if (!read_maze_from_file(input_filename, maze, start_x, start_y, end_x, end_y)) {
+        return 1;
+    }
+
+    // Выводим исходный лабиринт на экран
+    cout << "Исходный лабиринт:" << endl;
+    print_maze(maze);
+
+    // Применяем BFS для нахождения пути
+    if (bfs(maze, start_x, start_y, end_x, end_y)) {
+        cout << "\nМинимальный путь найден:" << endl;
+        print_maze(maze);
+    }
+    else {
+        cout << "\nIMPOSSIBLE" << endl;
+    }
+
+    // Запись результата в выходной файл
+    if (!write_maze_to_file(output_filename, maze)) {
+        return 1;
+    }
+
+    cout << "Решенный лабиринт записан в файл: " << output_filename << endl;
+
+    return 0;
+}

LibraryCPP/CMakeLists.txt

@@ -1,3 +1,3 @@
-add_library(LibraryCPP STATIC array.cpp list.cpp queue.cpp stack.cpp vector.cpp)
+add_library(LibraryCPP STATIC list.cpp queue.cpp)
 
-add_subdirectory(Tests)
+add_subdirectory(Tests)

LibraryCPP/Tests/CMakeLists.txt

@@ -3,16 +3,21 @@
 # target_link_libraries(TestArrayCPP LibraryCPP)
 # add_test(TestArrayCPP TestArrayCPP)
 
-# add_executable(TestListCPP list.cpp)
-# target_include_directories(TestListCPP PUBLIC ..)
-# target_link_libraries(TestListCPP LibraryCPP)
-# add_test(TestListCPP TestListCPP)
+# add_executable(TestArrayCPP array.cpp)
+# target_include_directories(TestArrayCPP PUBLIC ..)
+# target_link_libraries(TestArrayCPP LibraryCPP)
+# add_test(TestArrayCPP TestArrayCPP)
+
+add_executable(TestListCPP list.cpp)
+target_include_directories(TestListCPP PUBLIC ..)
+target_link_libraries(TestListCPP LibraryCPP)
+add_test(TestListCPP TestListCPP)
 
-# add_executable(TestQueueCPP queue.cpp)
-# target_include_directories(TestQueueCPP PUBLIC ..)
-# target_link_libraries(TestQueueCPP LibraryCPP)
-# add_test(TestQueueCPP TestQueueCPP)
-# set_tests_properties(TestQueueCPP PROPERTIES TIMEOUT 10)
+add_executable(TestQueueCPP queue.cpp)
+target_include_directories(TestQueueCPP PUBLIC ..)
+target_link_libraries(TestQueueCPP LibraryCPP)
+add_test(TestQueueCPP TestQueueCPP)
+set_tests_properties(TestQueueCPP PROPERTIES TIMEOUT 10)
 
 # add_executable(TestStackCPP stack.cpp)
 # target_include_directories(TestStackCPP PUBLIC ..)
@@ -23,4 +28,4 @@
 # target_include_directories(TestVectorCPP PUBLIC ..)
 # target_link_libraries(TestVectorCPP LibraryCPP)
 # add_test(TestVectorCPP TestVectorCPP)
-# set_tests_properties(TestVectorCPP PROPERTIES TIMEOUT 10)
+# set_tests_properties(TestVectorCPP PROPERTIES TIMEOUT 10)

LibraryCPP/Tests/list.cpp

@@ -1,48 +1,58 @@
 #include <iostream>
 #include "list.h"
 
-int main()
-{
-    List *list = list_create();
+int main() {
+    List* list = list_create();
 
-    if (!list)
-    {
+    if (!list) {
         std::cout << "List creation error\n";
         return 1;
     }
 
+    // Вставляем элементы 1, 2, 3 в конец списка.
     list_insert(list, 1);
     list_insert(list, 2);
     list_insert(list, 3);
 
-    if (list_item_data(list_first(list)) != 3)
-    {
-        std::cout << "list_insert error\n";
+    // Проверяем первый элемент (он должен быть 1).
+    if (list_item_data(list_first(list)) != 1) {
+        std::cout << "list_insert error: incorrect first element\n";
         return 1;
     }
 
+    // Вставляем 4 после первого элемента (1).
     list_insert_after(list, list_first(list), 4);
 
-    if (list_item_data(list_item_next(list_first(list))) != 4)
-    {
-        std::cout << "list_insert_after error\n";
+    // Проверяем, что следующий элемент после первого - 4.
+    if (list_item_data(list_item_next(list_first(list))) != 4) {
+        std::cout << "list_insert_after error: incorrect next element\n";
         return 1;
     }
 
+    // Удаляем первый элемент (1).
     list_erase_first(list);
 
-    if (list_item_data(list_first(list)) != 4)
-    {
-        std::cout << "list_erase error\n";
+    // Проверяем, что первый элемент теперь 4 (первый следующий после старого 1).
+    if (list_item_data(list_first(list)) != 4) {
+        std::cout << "list_erase error: incorrect first element after erase\n";
         return 1;
     }
 
+    // Печатаем список.
     std::cout << "List: ";
-    for (ListItem *item = list_first(list) ; item ; item = list_item_next(item))
-    {
-        std::cout << list_item_data(item) << " ";
+    ListItem* first = list_first(list);
+    if (first) {
+        ListItem* current = first;
+        do {
+            std::cout << list_item_data(current) << " ";
+            current = list_item_next(current);
+        } while (current != first);
     }
     std::cout << "\n";
 
+    // Удаляем список.
     list_delete(list);
-}
+    std::cout << "Test completed successfully.\n";
+
+    return 0;
+}

LibraryCPP/Tests/vector.cpp

@@ -1,4 +1,4 @@
 #include <iostream>
 #include "vector.h"
 
 int main()
@@ -17,7 +17,8 @@
 
     for (size_t i = 0 ; i < vector_size(vector) ; ++i)
     {
-        if (vector_get(vector, i) != (int)i)
+        // Приведение i к Data (беззнаковому типу)
+        if (vector_get(vector, i) != (Data)i)
         {
             std::cout << "Invalid vector element " << i << "\n";
             return 1;
@@ -45,7 +46,8 @@
 
     for (size_t i = 0 ; i < vector_size(vector) ; ++i)
     {
-        if (vector_get(vector, i) != (int)i)
+        // Приведение i к Data (беззнаковому типу)
+        if (vector_get(vector, i) != (Data)i)
         {
             std::cout << "Invalid vector element " << i << "\n";
             return 1;

LibraryCPP/array.cpp

@@ -1,4 +1,4 @@
 #include "array.h"
 
 struct Array
 {
@@ -31,4 +31,4 @@
 size_t array_size(const Array *arr)
 {
     return 0;
-}
+}

LibraryCPP/array.h

@@ -1,7 +1,7 @@
 #ifndef ARRAY_H
 #define ARRAY_H
 
 #include <cstddef>
 
 // Non-resizeable array
 // Stores integer values inside
@@ -10,18 +10,19 @@
 struct Array;
 
 // create array
-Array *array_create(size_t size);
+Array* array_create(size_t size);
 
 // delete array, free memory
-void array_delete(Array *arr);
+void array_delete(Array* arr);
 
 // returns specified array element
-Data array_get(const Array *arr, size_t index);
+Data array_get(const Array* arr, size_t index);
 
 // sets the specified array element to the value
-void array_set(Array *arr, size_t index, Data value);
+void array_set(Array* arr, size_t index, Data value);
 
 // returns array size
-size_t array_size(const Array *arr);
+size_t array_size(const Array* arr);
 
 #endif
+