lab2

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(LibraryC)
 add_subdirectory(LibraryCPP)
-add_subdirectory(LibraryCPPClass)
-add_subdirectory(LibraryCPPTemplate)
+#add_subdirectory(LibraryCPPClass)
+#add_subdirectory(LibraryCPPTemplate)
 
-add_subdirectory(Lab1C)
+add_subdirectory(Lab2CPP)

Lab2CPP/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(Lab2CPP lab2.cpp)
+target_include_directories(Lab2CPP PUBLIC ../LibraryCPP)
+target_link_libraries(Lab2CPP LibraryCPP)
+
+add_test(NAME TestLab2CPP COMMAND Lab2CPP ${CMAKE_CURRENT_SOURCE_DIR}/input.txt)

Lab2CPP/input.txt

@@ -0,0 +1,7 @@
+1+2*3-1
+(2+2)*3
+4+1-
+2*3+(4+4
+3/3*(2+5))+1
+4*2+1)
+)

Lab2CPP/lab2.cpp

@@ -0,0 +1,127 @@
+#include <iostream>
+#include <fstream>
+#include <stdexcept>
+#include "stack.h"  
+#include "vector.h" 
+#include <string>
+
+int precedence(char op) {
+    if (op == '+' || op == '-') return 1;
+    if (op == '*' || op == '/') return 2;
+    return 0;
+}
+
+int apply_operator(int a, int b, char op) {
+    switch (op) {
+    case '+': return a + b;
+    case '-': return a - b;
+    case '*': return a * b;
+    case '/':
+        if (b == 0) throw std::runtime_error("Division by zero");
+        return a / b;
+    default:
+        throw std::invalid_argument("Invalid operator");
+    }
+}
+
+int evaluate_example(const std::string& example) {
+    Stack* values = stack_create();
+    Stack* operators = stack_create();
+
+    for (size_t i = 0; i < example.length(); i++) {
+        if (example[i] == ' ') continue;
+
+        if (isdigit(example[i])) {
+            int value = 0;
+            while (i < example.length() && isdigit(example[i])) {
+                value = value * 10 + (example[i] - '0');
+                i++;
+            }
+            i--;
+            stack_push(values, value);
+        }
+        else if (example[i] == '(') {
+            stack_push(operators, example[i]);
+        }
+        else if (example[i] == ')') {
+            while ( stack_get(operators) != '(') {
+
+                int val2 = stack_get(values);
+                stack_pop(values);
+
+
+                int val1 = stack_get(values);
+                stack_pop(values);
+
+
+                char op = (char)stack_get(operators);
+                stack_pop(operators);
+
+                stack_push(values, apply_operator(val1, val2, op));
+            }
+            if (!stack_empty(operators)) {
+                stack_pop(operators); 
+            }
+            else {
+                throw std::runtime_error("Mismatched parentheses: no matching '(' found");
+            }
+        }
+        else if (example[i] == '+' || example[i] == '-' || example[i] == '*' || example[i] == '/') {
+            while (!stack_empty(operators) && precedence((char)stack_get(operators)) >= precedence(example[i])) {
+
+                int val2 = stack_get(values);
+                stack_pop(values);
+
+                int val1 = stack_get(values);
+                stack_pop(values);
+
+
+                char op = (char)stack_get(operators);
+                stack_pop(operators);
+
+                stack_push(values, apply_operator(val1, val2, op));
+            }
+            stack_push(operators, example[i]);
+        }
+    }
+
+    while (!stack_empty(operators)) {
+
+        int val2 = stack_get(values);
+        stack_pop(values);
+
+
+        int val1 = stack_get(values);
+        stack_pop(values);
+
+
+        char op = (char)stack_get(operators);
+        stack_pop(operators);
+
+        stack_push(values, apply_operator(val1, val2, op));
+    }
+
+
+        int result = stack_get(values);
+        stack_delete(values);
+        stack_delete(operators);
+        return result;
+
+}
+
+int main() {
+    std::ifstream inputFile("input.txt");
+    std::string example;
+
+    while (std::getline(inputFile, example)) {
+        try {
+            int result = evaluate_example(example);
+            std::cout << "Result: " << result << std::endl;
+        }
+        catch (const std::exception& e) {
+            std::cerr << "Error: " << e.what() << std::endl;
+        }
+    }
+
+    return 0;
+}

LibraryC/Tests/CMakeLists.txt

@@ -1,7 +1,7 @@
-add_executable(TestArrayC array.cpp)
-target_include_directories(TestArrayC PUBLIC ..)
-target_link_libraries(TestArrayC LibraryC)
-add_test(TestArrayC TestArrayC)
+#add_executable(TestArrayC array.cpp)
+#target_include_directories(TestArrayC PUBLIC ..)
+#target_link_libraries(TestArrayC LibraryC)
+#add_test(TestArrayC TestArrayC)
 
 # add_executable(TestListC list.cpp)
 # target_include_directories(TestListC PUBLIC ..)

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 stack.cpp vector.cpp)
 
 add_subdirectory(Tests)

LibraryCPP/Tests/CMakeLists.txt

@@ -1,7 +1,7 @@
-# add_executable(TestArrayCPP array.cpp)
-# target_include_directories(TestArrayCPP PUBLIC ..)
-# target_link_libraries(TestArrayCPP LibraryCPP)
-# add_test(TestArrayCPP TestArrayCPP)
+ #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 ..)
@@ -14,13 +14,13 @@
 # add_test(TestQueueCPP TestQueueCPP)
 # set_tests_properties(TestQueueCPP PROPERTIES TIMEOUT 10)
 
-# add_executable(TestStackCPP stack.cpp)
-# target_include_directories(TestStackCPP PUBLIC ..)
-# target_link_libraries(TestStackCPP LibraryCPP)
-# add_test(TestStackCPP TestStackCPP)
+ add_executable(TestStackCPP stack.cpp)
+ target_include_directories(TestStackCPP PUBLIC ..)
+ target_link_libraries(TestStackCPP LibraryCPP)
+ add_test(TestStackCPP TestStackCPP)
 
-# add_executable(TestVectorCPP vector.cpp)
-# target_include_directories(TestVectorCPP PUBLIC ..)
-# target_link_libraries(TestVectorCPP LibraryCPP)
-# add_test(TestVectorCPP TestVectorCPP)
-# set_tests_properties(TestVectorCPP PROPERTIES TIMEOUT 10)
+ add_executable(TestVectorCPP vector.cpp)
+ target_include_directories(TestVectorCPP PUBLIC ..)
+ target_link_libraries(TestVectorCPP LibraryCPP)
+ add_test(TestVectorCPP TestVectorCPP)
+ set_tests_properties(TestVectorCPP PROPERTIES TIMEOUT 10)

LibraryCPP/Tests/array.cpp

@@ -1,9 +1,9 @@
 #include <iostream>
 #include "array.h"
 
 int main()
 {
-    Array *arr = array_create(10);
+    Array* arr = array_create(10);
 
     if (array_size(arr) != 10)
     {

LibraryCPP/Tests/vector.cpp

@@ -1,5 +1,5 @@
 #include <iostream>
 #include "vector.h"
 
 int main()
 {
@@ -13,7 +13,7 @@
     }
 
     for (size_t i = 0 ; i < vector_size(vector) ; ++i)
-        vector_set(vector, i, i);
+        vector_set(vector, i, static_cast<Data>(i));
 
     for (size_t i = 0 ; i < vector_size(vector) ; ++i)
     {
@@ -61,7 +61,7 @@
     for (int i = 1 ; i <= 10000000 ; ++i)
     {
         vector_resize(vector, i);
-        vector_set(vector, i - 1, i);
+        vector_set(vector, static_cast<size_t>(i) - 1, i);
     }
 
     long long sum = 0;

LibraryCPP/array.cpp

@@ -1,34 +1,58 @@
 #include "array.h"
+#include <stdexcept>
 
 struct Array
 {
+    size_t size; 
+    Data* data;  
 };
 
 // create array
 Array *array_create(size_t size)
 {
-    return new Array;
+    if (size == 0) {
+        throw std::invalid_argument("Size must be greater than 0");
+    }
+
+    Array* arr = new Array;
+    arr->size = size;
+    arr->data = new Data[size]; 
+    return arr;
+
 }
 
 // delete array, free memory
 void array_delete(Array *arr)
 {
-    delete arr;
+    if (arr) {
+        delete[] arr->data; 
+        delete arr;         
+    }
+
 }
 
 // returns specified array element
 Data array_get(const Array *arr, size_t index)
 {
-    return (Data)0;
+    if (index >= arr->size) {
+        throw std::out_of_range("Index out of range");
+    }
+    return arr->data[index]; 
+
 }
 
 // sets the specified array element to the value
 void array_set(Array *arr, size_t index, Data value)
 {
+    if (index >= arr->size) {
+        throw std::out_of_range("Index out of range");
+    }
+    arr->data[index] = value; 
 }
 
 // returns array size
 size_t array_size(const Array *arr)
 {
-    return 0;
+    return arr->size; 
+
 }