Update 'readme.md'

Примечание: В данном коде предполагается, что введенные пользователем данные корректны. На практике, для полной надежности, следует добавить проверки на корректность ввода данных.

lab04.cbp

@@ -35,10 +35,8 @@
 		<Unit filename=".gitignore">
 			<Option target="&lt;{~None~}&gt;" />
 		</Unit>
-		<Unit filename="calc_bits.cpp" />
 		<Unit filename="lab04.h" />
 		<Unit filename="main.cpp" />
-		<Unit filename="source.cpp" />
 		<Extensions>
 			<lib_finder disable_auto="1" />
 		</Extensions>

lab04.h

@@ -1,8 +1,10 @@
 #ifndef LAB04_H_INCLUDED
 #define LAB04_H_INCLUDED
+
 #include <iostream>
 #include <iomanip>
 #include <cstdint>
+#include <cstring>
 #pragma once
 
 void print_in_hex(uint8_t byte);
@@ -12,4 +14,24 @@ void print_in_binary(const void* data, size_t size);
 uint16_t perform_bitwise_operation(uint16_t operand1, char operation, uint16_t operand2);
 void print_calculation(uint16_t result);
 
+// Student
+struct Student {
+    char name[17];
+    uint16_t admissionYear;
+    float averageGrade;
+    unsigned int gender : 1;
+    unsigned int completedCourses;
+    Student* groupLeader;
+
+    // Initialisation
+    Student(const char* n, uint16_t year, float grade, unsigned int g, unsigned int courses, Student* leader)
+        : admissionYear(year), averageGrade(grade), gender(g), completedCourses(courses), groupLeader(leader)
+    {
+        strncpy(name, n, sizeof(name) - 1);
+        name[sizeof(name) - 1] = '\0';
+    }
+};
+
+void printStudentDetails(const Student& student);
+
 #endif // LAB04_H_INCLUDED

main.cpp

@@ -1,45 +1,72 @@
 #include <iostream>
 #include <iomanip>
-#include "lab04.h"
-
+#include <cstring>
+#include <bitset>
 
 using namespace std;
 
+struct Student {
+    char name[17];
+    uint16_t admissionYear;
+    float averageGrade;
+    bool isMale : 1;
+    uint8_t completedCourses;
+    Student* groupLeader;
+};
+
 int main() {
-    uint8_t singleByte = 0xAB;
-    uint8_t byteArray[] = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0 };
+    const int numberOfStudents = 3;
+    Student students[numberOfStudents];
 
-    cout << "Print in Hex:" << endl;
-    print_in_hex(singleByte);
+    students[0].admissionYear = 2023;
+    students[0].averageGrade = 4.5;
+    students[0].isMale = true;
+    students[0].completedCourses = 5;
+    students[0].groupLeader = nullptr;
 
-    cout << endl;
-    print_in_hex(byteArray, sizeof(byteArray));
+    students[1].admissionYear = 2022;
+    students[1].averageGrade = 3.8;
+    students[1].isMale = false;
+    students[1].completedCourses = 6;
+    students[1].groupLeader = &students[0];
 
-    cout << "\nPrint in Binary:" << endl;
-    print_in_binary(singleByte);
-    cout << endl;
-    print_in_binary(byteArray, sizeof(byteArray));
-
-    return 0;
-}
-
-int main_calc(){
-    uint16_t operand1, operand2;
-    char operation;
-
-    cout << "Enter the first operand (in hexadecimal): ";
-    cin >> std::hex >> operand1;
-
-    cout << "Enter the bitwise operation (&, |, or ^): ";
-    cin >> operation;
-
-    cout << "Enter the second operand (in hexadecimal): ";
-    cin >> std::hex >> operand2;
-
-    uint16_t result = perform_bitwise_operation(operand1, operation, operand2);
-
-    cout << "\nCalculation Result:" << endl;
-    print_calculation(result);
+    students[2].admissionYear = 2021;
+    students[2].averageGrade = 3.2;
+    students[2].isMale = true;
+    students[2].completedCourses = 7;
+    students[2].groupLeader = nullptr;
+
+    for (int i = 0; i < numberOfStudents; ++i) {
+        cout << "\nÈíôîðìàöèÿ î ñòóäåíòå " << i + 1 << ":\n";
+        cout << "Àäðåñ ïîëÿ admissionYear: " << static_cast<void*>(&students[i].admissionYear) << ", Ñìåùåíèå: "
+             << offsetof(Student, admissionYear) << ", Ðàçìåð: " << sizeof(students[i].admissionYear) << " áàéò, "
+             << "Øåñòíàäöàòåðè÷íîå: " << hex << students[i].admissionYear << ", Äâîè÷íîå: "
+             << bitset<16>(students[i].admissionYear) << '\n';
+
+        cout << "Àäðåñ ïîëÿ averageGrade: " << static_cast<void*>(&students[i].averageGrade) << ", Ñìåùåíèå: "
+             << offsetof(Student, averageGrade) << ", Ðàçìåð: " << sizeof(students[i].averageGrade) << " áàéò, "
+             << "Çíà÷åíèå: " << students[i].averageGrade << '\n';
+
+        cout << "Àäðåñ è áèòîâîå ïîëå isMale: " << static_cast<void*>(&students[i].isMale) << ", Ñìåùåíèå: "
+             << offsetof(Student, isMale) << ", Ðàçìåð: " << sizeof(students[i].isMale) << " áèò, "
+             << "Çíà÷åíèå: " << (students[i].isMale ? "ìóæñêîé" : "æåíñêèé") << '\n';
+
+        cout << "Àäðåñ ïîëÿ completedCourses: " << static_cast<void*>(&students[i].completedCourses) << ", Ñìåùåíèå: "
+             << offsetof(Student, completedCourses) << ", Ðàçìåð: " << sizeof(students[i].completedCourses) << " áàéò, "
+             << "Çíà÷åíèå: " << static_cast<int>(students[i].completedCourses) << '\n';
+
+        cout << "Àäðåñ ïîëÿ groupLeader: " << static_cast<void*>(&students[i].groupLeader) << ", Ñìåùåíèå: "
+             << offsetof(Student, groupLeader) << ", Ðàçìåð: " << sizeof(students[i].groupLeader) << " áàéò, "
+             << "Øåñòíàäöàòåðè÷íîå: " << hex << reinterpret_cast<uintptr_t>(students[i].groupLeader) << '\n';
+
+        // Âûâîäèì ïðåäñòàâëåíèå ñòðóêòóðû â ïàìÿòè
+        cout << "Ïðåäñòàâëåíèå â ïàìÿòè (â øåñòíàäöàòåðè÷íîé ñèñòåìå):\n";
+        const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&students[i]);
+        for (size_t j = 0; j < sizeof(Student); ++j) {
+            cout << hex << setfill('0') << setw(2) << static_cast<int>(bytes[j]) << ' ';
+        }
+        cout << '\n';
+    }
 
     return 0;
 }

readme.md

@@ -0,0 +1,487 @@
+## Лабораторная работа № 4
+#### 1. Представление данных в памяти
+
+Начнем с реализации функции `nibble_to_hex()` и тестов для нее. После этого мы создадим функцию `print_in_hex()` с использованием `nibble_to_hex()`.<br>
+
+```
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+
+// Функция для представления nibble (4 бит) в шестнадцатеричной системе
+char nibble_to_hex(uint8_t i) {
+    // Массив цифр в шестнадцатеричной системе
+    char digits[] = "0123456789abcdef";
+    
+    // Проверка на корректность аргумента
+    assert(0x0 <= i && i <= 0xf);
+    
+    // Возвращаем символ для nibble из массива digits
+    return digits[i];
+}
+```
+Напишем реализацию функции `print_in_hex()` для печати одного байта в шестнадцатеричной и двоичной форме:<br>
+```
+// Функция для печати одного байта в шестнадцатеричной и двоичной форме
+void print_in_hex(uint8_t byte) {
+    // Печать в шестнадцатеричной форме
+    cout << "Hex: " << nibble_to_hex(byte >> 4) << nibble_to_hex(byte & 0xf) << endl;
+    
+    // Печать в двоичной форме
+    cout << "Binary: ";
+    for (int i = 7; i >= 0; --i) {
+        cout << ((byte >> i) & 1);
+    }
+    cout << std::endl;
+}
+```
+Итак, выполним проверку работы `nibble_to_hex()`, добавим в программу функцию-тест, вызываемую в начале main():
+```
+int main() {
+
+    // Тестирование функции nibble_to_hex
+    
+   	assert(nibble_to_hex(0x0) == '0');
+    assert(nibble_to_hex(0x1) == '1');
+    assert(nibble_to_hex(0x2) == '2');
+    assert(nibble_to_hex(0x3) == '3');
+    assert(nibble_to_hex(0x4) == '4');
+    assert(nibble_to_hex(0x5) == '5');
+    assert(nibble_to_hex(0x6) == '6');
+    assert(nibble_to_hex(0x7) == '7');
+    assert(nibble_to_hex(0x8) == '8');
+    assert(nibble_to_hex(0x9) == '9');
+    assert(nibble_to_hex(0xa) == 'a');
+    assert(nibble_to_hex(0xb) == 'b');
+    assert(nibble_to_hex(0xc) == 'c');
+    assert(nibble_to_hex(0xd) == 'd');
+    assert(nibble_to_hex(0xe) == 'e');
+    assert(nibble_to_hex(0xf) == 'f');
+```
+Также проверку можно выполнить в цикле чтобы код не был таким громоздким:
+```
+for (int i = 0; i <= 0xf; ++i) {
+        assert(nibble_to_hex(i) == nibble_to_hex(i));
+    }
+```
+Теперь напечатаем байт в шестнадцатеричной и двоичной форме:<>br
+```
+using namespace std;
+
+// Функция для печати одного байта в шестнадцатеричной и двоичной форме
+void print_in_hex(uint8_t byte) {
+
+    // Печать в шестнадцатеричной форме
+    cout << "Hex: " << nibble_to_hex(byte >> 4) << nibble_to_hex(byte & 0xf) << endl;
+    
+    // Печать в двоичной форме
+    cout << "Binary: ";
+    for (int i = 7; i >= 0; --i) {
+        cout << ((byte >> i) & 1);
+    }
+    cout << endl;
+}
+```
+Теперь заключим преобразование типов  в функцию `const uint8_t* as_bytes(const void* data)`:
+```
+// Функция для преобразования типов
+const uint8_t* as_bytes(const void* data) {
+    return reinterpret_cast<const uint8_t*>(data);
+}
+```
+Также напишем функцию для печати массива байтов:
+```
+// Функция для печати массива байтов
+void print_in_hex(const void* data, size_t size) {
+    const uint8_t* bytes = as_bytes(data);
+    for (size_t i = 0; i < size; i++) {
+        print_in_hex(bytes[i]);
+
+        // Для удобства чтения: пробелы между байтами, по 16 байт на строку.
+        if ((i + 1) % 16 == 0) {
+            cout << '\n';
+        } else {
+            cout << ' ';
+        }
+    }
+    cout << endl;
+}
+```
+Теперь функция `as_bytes` принимает указатель на данные и возвращает указатель на байты этих данных, используя `reinterpret_cast`. Пример использования данной функции добавлен в `main()`, где  мы создаем переменные u8, u16 и u32, присваиваем им значение 0x42, а затем выводим их байтовое представление, используя функцию `print_in_hex`:
+```
+int main() {
+    uint8_t u8 = 0x42;
+    uint16_t u16 = 0x42;
+    uint32_t u32 = 0x42;
+
+    cout << "u8 bytes: ";
+    print_in_hex(&u8, sizeof(u8));
+    cout << '\n';
+
+    cout << "u16 bytes: ";
+    print_in_hex(&u16, sizeof(u16));
+    cout << '\n';
+
+    cout << "u32 bytes: ";
+    print_in_hex(&u32, sizeof(u32));
+    cout << '\n';
+
+    return 0;
+}
+```
+Добавим функцию `bit_digit` для проверки битов переменных u8, u16, и u32, и их вывода в двоичной системе. Обновим функцию `print_in_binary`. Теперь функция `print_in_binary` использует цикл для вывода битов переменных `u8`, `u16`, и `u32` в двоичной системе.
+
+
+```
+using namespace std;
+
+// Функция для проверки битов и вывода их в двоичной системе
+char bit_digit(uint8_t byte, uint8_t bit) {
+    if (byte & (0x1 << bit)) {
+        return '1';
+    }
+    return '0';
+}
+
+// Функция для печати байта в двоичной системе
+void print_in_binary(uint8_t byte) {
+    for (uint8_t bit = 7; bit > 0; bit--) {
+        cout << bit_digit(byte, bit);
+    }
+}
+
+int main() {
+    uint8_t u8 = 0x42;
+    uint16_t u16 = 0x42;
+    uint32_t u32 = 0x42;
+
+    cout << "u8 bytes: ";
+    print_in_hex(&u8, sizeof(u8));
+
+    cout << "\nu8 binary: ";
+    print_in_binary(u8);
+    cout << '\n';
+
+    cout << "\nu16 bytes: ";
+    print_in_hex(&u16, sizeof(u16));
+
+    cout << "\nu16 binary: ";
+    print_in_binary(u16);
+    cout << '\n';
+
+    cout << "\nu32 bytes: ";
+    print_in_hex(&u32, sizeof(u32));
+
+    cout << "\nu32 binary: ";
+    print_in_binary(u32);
+    cout << '\n';
+
+    return 0;
+}
+```
+Переведем в двоичное представление и напечатаем числа из лекционного слайда про двоичные операции (исходные два числа и результаты всех действий).
+```
+int main() {
+    // Два числа для примера
+    uint8_t num1 = 0b11011011;  // 219 в десятичной системе
+    uint8_t num2 = 0b00101101;  // 45 в десятичной системе
+
+    // Вывод двоичного представления чисел
+    cout << "num1 в двоичной системе: ";
+    print_in_binary(num1);
+    cout << " (" << static_cast<int>(num1) << " в десятичной системе)\n";
+
+    cout << "num2 в двоичной системе: ";
+    print_in_binary(num2);
+    cout << " (" << static_cast<int>(num2) << " в десятичной системе)\n";
+
+    return 0;
+}
+```
+Напишем функцию `print_in_binary` для вывода массива байтов в двоичной системе по аналогии с `print_in_hex()`:
+```
+using namespace std;
+
+void print_in_binary(const void* data, size_t size) {
+    const uint8_t* bytes = as_bytes(data);
+    for (size_t i = 0; i < size; i++) {
+        print_in_binary(bytes[i]);
+
+        // Для удобства чтения: пробелы между байтами, по 4 байта на строку.
+        if ((i + 1) % 4 == 0) {
+            cout << '\n';
+        } else {
+            cout << ' ';
+        }
+    }
+    cout << endl;
+}
+
+int main() {
+    // Примеры чисел для тестирования
+    uint32_t u32 = 0x42424242;  // 4,294,967,042 в десятичной системе
+    uint16_t u16 = 0x4242;      // 16,642 в десятичной системе
+
+    cout << "u32 в двоичной системе:\n";
+    print_in_binary(&u32, sizeof(u32));
+
+    cout << "\nu16 в двоичной системе:\n";
+    print_in_binary(&u16, sizeof(u16));
+
+    return 0;
+}
+```
+Cоздаем два числа (`u32` и `u16`), переводим их в двоичное представление, и затем используем функцию `print_in_binary` для вывода байтов в двоичной системе.
+
+#### 2. Битовый калькулятор.
+Напишем программу-калькулятор для побитовых операций.
+```
+#include <iostream>
+#include <cstdint>
+#include <iomanip>
+
+using namespace std;
+
+// Функция для проверки битов и вывода их в двоичной системе
+char bit_digit(uint16_t num, uint8_t bit) {
+    return (num & (0x1 << bit)) ? '1' : '0';
+}
+
+// Функция для печати числа в двоичной системе
+void print_in_binary(uint16_t num) {
+    for (int8_t bit = 15; bit >= 0; --bit) {
+        cout << bit_digit(num, bit);
+    }
+}
+
+int main() {
+    uint16_t operand1, operand2, result;
+    char operation;
+
+    // Ввод первого операнда, оператора и второго операнда
+    cout << "Введите первый операнд (в шестнадцатеричной форме): ";
+    cin >> hex >> operand1;
+
+    cout << "Введите оператор (&, | или ^): ";
+    cin >> operation;
+
+    cout << "Введите второй операнд (в шестнадцатеричной форме): ";
+    cin >> std::hex >> operand2;
+
+    // Выполнение операции в зависимости от введенного оператора
+    switch (operation) {
+        case '&':
+            result = operand1 & operand2;
+            break;
+        case '|':
+            result = operand1 | operand2;
+            break;
+        case '^':
+            result = operand1 ^ operand2;
+            break;
+        default:
+            std::cerr << "Неверный оператор. Допустимые операторы: &, |, ^.\n";
+            return 1;
+    }
+
+    // Вывод результата в шестнадцатеричной и двоичной форме
+    cout << hex << setw(4) << setfill('0') << operand1 << ' ' << operation << ' '
+              << setw(4) << setfill('0') << operand2 << " = " << setw(4) << setfill('0') << result
+              << '\n';
+
+    cout << setw(16) << setfill(' ') << left << "в двоичной системе: ";
+    print_in_binary(operand1);
+    cout << ' ' << operation << ' ';
+    print_in_binary(operand2);
+    cout << " = ";
+    print_in_binary(result);
+    cout << '\n';
+
+    return 0;
+}
+```
+Тут программа предлагает пользователю ввести два операнда и оператор (`&`, `|` или `^`). Затем он выполняет выбранную операцию и выводит результат в шестнадцатеричной и двоичной форме.
+
+#### 3. Исследование представления и размещения данных в памяти
+
+
+
+```
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <bitset>
+
+using namespace std;
+
+struct Student {
+    char name[17];
+    uint16_t admissionYear;
+    float averageGrade;
+    bool isMale : 1;
+    uint8_t completedCourses;
+    Student* groupLeader;
+};
+
+int main() {
+    const int numberOfStudents = 3;
+    Student students[numberOfStudents];
+
+    students[0].admissionYear = 2023;
+    students[0].averageGrade = 4.5;
+    students[0].isMale = true;
+    students[0].completedCourses = 5;
+    students[0].groupLeader = nullptr;
+
+    students[1].admissionYear = 2022;
+    students[1].averageGrade = 3.8;
+    students[1].isMale = false;
+    students[1].completedCourses = 6;
+    students[1].groupLeader = &students[0];
+
+    students[2].admissionYear = 2021;
+    students[2].averageGrade = 3.2;
+    students[2].isMale = true;
+    students[2].completedCourses = 7;
+    students[2].groupLeader = nullptr;
+
+    for (int i = 0; i < numberOfStudents; ++i) {
+        cout << "\nИнформация о студенте " << i + 1 << ":\n";
+        cout << "Адрес поля admissionYear: " << static_cast<void*>(&students[i].admissionYear) << ", Смещение: "
+             << offsetof(Student, admissionYear) << ", Размер: " << sizeof(students[i].admissionYear) << " байт, "
+             << "Шестнадцатеричное: " << hex << students[i].admissionYear << ", Двоичное: "
+             << bitset<16>(students[i].admissionYear) << '\n';
+
+        cout << "Адрес поля averageGrade: " << static_cast<void*>(&students[i].averageGrade) << ", Смещение: "
+             << offsetof(Student, averageGrade) << ", Размер: " << sizeof(students[i].averageGrade) << " байт, "
+             << "Значение: " << students[i].averageGrade << '\n';
+
+        cout << "Адрес и битовое поле isMale: " << static_cast<void*>(&students[i].isMale) << ", Смещение: "
+             << offsetof(Student, isMale) << ", Размер: " << sizeof(students[i].isMale) << " бит, "
+             << "Значение: " << (students[i].isMale ? "мужской" : "женский") << '\n';
+
+        cout << "Адрес поля completedCourses: " << static_cast<void*>(&students[i].completedCourses) << ", Смещение: "
+             << offsetof(Student, completedCourses) << ", Размер: " << sizeof(students[i].completedCourses) << " байт, "
+             << "Значение: " << static_cast<int>(students[i].completedCourses) << '\n';
+
+        cout << "Адрес поля groupLeader: " << static_cast<void*>(&students[i].groupLeader) << ", Смещение: "
+             << offsetof(Student, groupLeader) << ", Размер: " << sizeof(students[i].groupLeader) << " байт, "
+             << "Шестнадцатеричное: " << hex << reinterpret_cast<uintptr_t>(students[i].groupLeader) << '\n';
+
+        // Выводим представление структуры в памяти
+        cout << "Представление в памяти (в шестнадцатеричной системе):\n";
+        const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&students[i]);
+        for (size_t j = 0; j < sizeof(Student); ++j) {
+            cout << hex << setfill('0') << setw(2) << static_cast<int>(bytes[j]) << ' ';
+        }
+        cout << '\n';
+    }
+
+    return 0;
+}
+```
+Тут мы создаем структуру `Student`, представляющую информацию о студенте, и инициализирует массив из трех студентов. Затем он выводит различные характеристики каждого студента, такие как адреса и размеры полей, значение полей, а также представление каждой структуры в памяти в шестнадцатеричном виде. Кроме того, он учитывает битовое поле `isMale` и выводит его адрес, смещение, размер и значение.
+
+#### 4. Работа со строками C
+
+```
+#include <iostream>
+#include <fstream>
+#include <cstring>
+#include <cctype>
+
+const int MAX_FILENAME_LENGTH = 256;
+const int MAX_INPUT_STRING_LENGTH = 256;
+
+bool isValidFilename(const char* filename) {
+    // Проверка наличия запрещенных символов
+    const char* forbiddenChars = "*\"<>?|";
+    if (strpbrk(filename, forbiddenChars) != nullptr) {
+        return false;
+    }
+
+    // Проверка наличия двоеточия
+    const char* colonPosition = strchr(filename, ':');
+    if (colonPosition != nullptr) {
+        if (colonPosition == filename + 1 && isalpha(filename[0])) {
+            // Проверка двоеточия только вторым символом
+            const char* backslashPosition = strchr(colonPosition + 1, '\\');
+            if (backslashPosition == nullptr) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    // Проверка расширения файла
+    const char* extension = strrchr(filename, '.');
+    if (extension != nullptr) {
+        if (strcmp(extension, ".txt") != 0 && strcmp(extension, ".TXT") != 0) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+int main() {
+    // Запрос имени файла
+    char filename[MAX_FILENAME_LENGTH];
+    std::cout << "Введите имя файла: ";
+    std::cin.getline(filename, MAX_FILENAME_LENGTH);
+
+    // Проверка корректности имени файла
+    if (!isValidFilename(filename)) {
+        std::cerr << "Некорректное имя файла.\n";
+        return 1;
+    }
+
+    // Добавление расширения .txt, если его нет
+    if (strrchr(filename, '.') == nullptr) {
+        strcat(filename, ".txt");
+    }
+
+    // Открытие файла
+    std::ifstream file(filename, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Ошибка открытия файла.\n";
+        return 1;
+    }
+
+    // Определение размера файла
+    file.seekg(0, std::ios::end);
+    std::streampos fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    // Выделение памяти под содержимое файла
+    char* fileContent = new char[fileSize];
+
+    // Чтение содержимого файла в память
+    file.read(fileContent, fileSize);
+    file.close();
+
+    // Запрос строки от пользователя
+    char inputString[MAX_INPUT_STRING_LENGTH];
+    std::cout << "Введите строку для поиска: ";
+    std::cin.getline(inputString, MAX_INPUT_STRING_LENGTH);
+
+    // Подсчет вхождений строки в файл
+    int occurrences = 0;
+    char* position = fileContent;
+    while ((position = strstr(position, inputString)) != nullptr) {
+        occurrences++;
+        position += strlen(inputString);
+    }
+
+    // Вывод результата
+    std::cout << "Число вхождений строки в файл: " << occurrences << std::endl;
+
+    // Освобождение выделенной памяти
+    delete[] fileContent;
+
+    return 0;
+}
+```
+Данный код выполняет все шаги, описанные в задании: запрос имени файла, проверка корректности имени, добавление расширения .txt, загрузка содержимого файла в память, запрос строки от пользователя, подсчет и вывод числа вхождений строки в файл, а затем освобождение памяти.

source.cpp

@@ -1,5 +1,4 @@
 #include "lab04.h"
-#include "calc_bits.h"
 #include <string>