Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-11-20· OpenAIAi2 WildChat-4.8M (AI2)

в чем проблема в данном коде: extern "C" __declspec(dllimport) struct User*…

  1. User

    в чем проблема в данном коде: extern "C" __declspec(dllimport) struct User* parse_data(TCHAR path[], int* n); struct User* parse_data(TCHAR path[], int* n) { HANDLE fh; DWORD dwcount;

    wprintf(L"%s", path);
    char buffer[N_BUFF];
    fh = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (fh == INVALID_HANDLE_VALUE)
    {
        printf("Не удалось открыть указанный файл");
        exit(-1);
    }
    if (!ReadFile(fh, buffer, sizeof(buffer) - 1, &dwcount, NULL)) {
        printf("Ошибка чтения данных из файла");
        exit(-1);
    }
    buffer[dwcount] = '\0';
    CloseHandle(fh);
    char* token = strtok(buffer, "\n");
    struct User* users = (struct User*)malloc(500 * sizeof(struct User));
    char** users_str = (char**)malloc(sizeof(char*) * 100);
    char** users_str1 = (char**)malloc(sizeof(char*) * 100);
    int i = 0;
    
    
    while (token != NULL) {
        users_str[i] = (char*)malloc(sizeof(char) * 200);
        strcpy(users_str[i], token);
        token = strtok(NULL, "\n");
        i++;
    
    }
    (*n) = i;
    for (int j = 0; j < i; j++) {
        printf("%s\n", users_str1[0]);
        printf("%s\n", users_str1[1]);
        printf("%s\n", users_str1[2]);
        printf("%s\n", users_str1[3]);
        users_str1 = split_string(users_str[j]);
        strcpy(users[j].last_name, users_str1[0]);
        strcpy(users[j].first_name, users_str1[1]);
        strcpy(users[j].patronymic, users_str1[2]);
        users[j].age = atoi(users_str1[3]);
    
    }
    return users;
    

    }

  2. Assistant

    На первый взгляд в вашем коде есть несколько проблем. Я опишу основные потенциальные ошибки и неточности:


    1. Конфликт между __declspec(dllimport) и реализацией функции

    • Вы пометили функцию parse_data как extern "C" __declspec(dllimport), но при этом предоставили ее реализацию в этом же файле.
    • __declspec(dllimport) указывает, что реализация этой функции должна находиться в другой сборке (динамической библиотеке), а не в данном коде. Определение функции в этом файле вызывает конфликт.

    Исправление: Уберите либо реализацию, либо атрибут dllimport. Например:

    extern "C" __declspec(dllexport) struct User* parse_data(TCHAR path[], int* n);
    

    Либо уберите __declspec(dllimport)/dllimport вообще, если эта функция не предназначена для экспортируемой DLL-библиотеки.


    2. Неполное определение структуры struct User

    • В коде не представлено определение структуры struct User.
    • Компилятор не сможет понять, как использовать поля структуры last_name, first_name, и т.д., так что нужно внести соответствующее определение структуры.

    Например:

    struct User {
        char last_name[50];
        char first_name[50];
        char patronymic[50];
        int age;
    };
    

    3. Ошибка при создании и использовании массива users_str1

    • В цикле for вы перезаписываете указатель users_str1:
      users_str1 = split_string(users_str[j]);
      
      Вместо этого следует выделить отдельную память под результат split_string, если эта функция возвращает массив строк.

    Предполагаемое исправление: Убедитесь, что split_string() корректно выделяет память и возвращает массив строк, который можно заполнять.

    Вдобавок, вы используете users_str1[0], users_str1[1] и другие индексы без подтверждения, что split_string() возвращает корректные строки. Убедитесь, что данные корректно инициализированы.


    4. Вывод неинициализированных строк

    В этом блоке:

    printf("%s\n", users_str1[0]);
    printf("%s\n", users_str1[1]);
    printf("%s\n", users_str1[2]);
    printf("%s\n", users_str1[3]);
    

    Вы выводите содержимое элементов users_str1, не убедившись, что они инициализированы (например, после вызова split_string).


    5. Неочищенная выделенная память

    • Вы выделяете память динамически (через malloc), но нигде не освобождаете ее.
    • Это приводит к утечке памяти.

    Пример фиксации: после завершения работы функции освободите выделенную память:

    for (int j = 0; j < i; j++) {
        free(users_str[j]);
    }
    free(users_str);
    

    6. Проблемы с strtok

    • Использование strtok потенциально небезопасно, особенно в многопоточных окружениях.
    • Если вы планируете многопоточное приложение, лучше использовать библиотеку strtok_s (в среде Visual Studio) или ее эквиваленты.

    7. Размеры массивов

    • Вы используете магические числа, например, размер:

      char buffer[N_BUFF];
      

      но N_BUFF не определен в предоставленном коде.

      Убедитесь, что он определен, например:

      #define N_BUFF 1024
      

    8. Ошибка в обработке файла

    Проверка открытия файла:

    if (fh == INVALID_HANDLE_VALUE)
    {
        printf("Не удалось открыть указанный файл");
        exit(-1);
    }
    

    Здесь вы вызываете exit(-1), что не всегда желательно. Лучше возвращать NULL или другой код ошибки для дальнейшей обработки.


    9. Проблемы с TCHAR path[]

    • Вы используете TCHAR path[], что может быть неудобно, особенно при использовании современных типов строк (например, std::wstring или std::string).
    • Если вы компилируете для Unicode, убедитесь, что TCHAR последовательно используется во всех вызовах. Например, функции CreateFile и wprintf должны соответствовать.

    Итог:

    Обновленный код может выглядеть так (пример):

    #define N_BUFF 1024
    struct User {
        char last_name[50];
        char first_name[50];
        char patronymic[50];
        int age;
    };
    
    extern "C" struct User* parse_data(TCHAR path[], int* n) {
        HANDLE fh;
        DWORD dwcount;
    
        wprintf(L"%s", path);
    
        char buffer[N_BUFF];
        fh = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    
        if (fh == INVALID_HANDLE_VALUE) {
            printf("Не удалось открыть указанный файл\n");
            return NULL;
        }
    
        if (!ReadFile(fh, buffer, sizeof(buffer) - 1, &dwcount, NULL)) {
            printf("Ошибка чтения данных из файла\n");
            CloseHandle(fh);
            return NULL;
        }
    
        buffer[dwcount] = '\0';
        CloseHandle(fh);
    
        char* token = strtok(buffer, "\n");
        struct User* users = (struct User*)malloc(500 * sizeof(struct User));
        char** users_str = (char**)malloc(sizeof(char*) * 100);
        int i = 0;
    
        while (token != NULL) {
            users_str[i] = (char*)malloc(sizeof(char) * 200);
            strcpy(users_str[i], token);
            token = strtok(NULL, "\n");
            i++;
        }
    
        (*n) = i;
    
        for (int j = 0; j < i; j++) {
            char** users_str1 = split_string(users_str[j]);
            if (users_str1) {
                strcpy(users[j].last_name, users_str1[0]);
                strcpy(users[j].first_name, users_str1[1]);
                strcpy(users[j].patronymic, users_str1[2]);
                users[j].age = atoi(users_str1[3]);
    
                // Здесь добавьте освобождение users_str1 при необходимости
            }
            free(users_str[j]);
        }
    
        free(users_str);
        return users;
    }
    
  3. User

    Вызвано исключение по адресу 0x00007FF99DF4AC87 (ucrtbased.dll) в UsingWinDLL.exe: 0xC0000005: нарушение прав доступа при чтении по адресу 0xFFFFFFFFFFFFFFFF. #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <Windows.h> #define LIB_PATH L"WinDLL.dll" #define N 50

    typedef char** (split)(char str); typedef struct User* (parse)(TCHAR path[], int n); typedef void (write)(struct User users, int n, char* path, int with_avg); typedef double (find_avg)(struct User users, int n); typedef int (str_search)(char string, char* substring); typedef struct User* (find_ln)(char surname, struct User* users, int n, int* matches_n);

    struct User { char last_name[N]; char first_name[N]; char patronymic[N]; int age; };

    int WINAPI main(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { system("chcp 1251 > null"); HINSTANCE MyDLL;

    if (!(MyDLL = LoadLibrary(LIB_PATH))) return 1;
    
    split split_string = GetProcAddress(MyDLL, "split_string");
    parse parse_data = GetProcAddress(MyDLL, "parse_data");
    write write_data = GetProcAddress(MyDLL, "write_data");
    find_avg find_average = GetProcAddress(MyDLL, "find_average");
    str_search string_search = GetProcAddress(MyDLL, "string_search");
    find_ln find_surname = GetProcAddress(MyDLL, "find_surname");
    
    struct User* users = malloc(sizeof(struct User));
    int flag = 1;
    int a, b, c;
    int n = 0;
    int matches_n = 0;
    TCHAR current_read_path[80] = L"E:\\Programming\\C\\WinDLLProper\\WinDLL\\UsingWinDLL\\users.csv";//"D:\\ЗрячевТА\\users.csv";
    char current_write_path[50] = "output.csv";
    char search_ln[50];
    struct User* matches = malloc(sizeof(struct User));
    while (flag)
    {
        printf("Текущий путь считывания: %s\nТекущий путь записи: %s\nЧто вы хотите сделать?\n"
            "1. Считать данные пользователей\n2. Вывести данные пользователей\n"
            "3. Поиск по фамилии\n4. Средний возраст\n5. Записать в файл\n6. Выход\n", current_read_path, current_write_path);
        scanf("%d", &a);
        switch (a)
        {
        case 1:
            users = parse_data(current_read_path, &n);
            printf("Данные были считаны\n");
            break;
        case 2:
            printf("Пользователи\n");
            for (int i = 0; i < n; i++) {
                printf("%d. %s %s %s %d\n", i + 1, users[i].last_name, users[i].first_name, users[i].patronymic, users[i].age);
            }
            break;
        case 3:
            printf("Введите фамилию для поиска:\n");
            scanf("%s", search_ln);
            matches = find_surname(search_ln, users, n, &matches_n);
            for (int i = 0; i < matches_n; i++) {
                printf("%d. %s %s %s %d\n", i + 1, matches[i].last_name, matches[i].first_name, matches[i].patronymic, matches[i].age);
            }
            break;
        case 4:
            printf("Средний возраст пользователей: %.2lf\n", find_average(users, n));
            printf("Средний возраст совпадение: %.2lf\n", find_average(matches, matches_n));
            break;
        case 5:
            printf("Что записать?\n1. Пользователей\n2. Совпадения\n");
            scanf("%d", &b);
            printf("Добавить данные о среднем возрасте?\n1. Да\n2. Нет\n");
            scanf("%d", &c);
            if (b == 1 & c == 1) {
                write_data(users, n, current_write_path, 1);
            }
            else if (b == 2 & c == 1) {
                write_data(matches, matches_n, current_write_path, 1);
            }
            else if (b == 1 & c == 2) {
                write_data(users, n, current_write_path, 0);
            }
            else if (b == 2 & c == 2) {
                write_data(matches, matches_n, current_write_path, 0);
            }
            else {
                break;
            }
    
    
            printf("Данные были записаны в файл %s\n", current_write_path);
            break;
        default:
            flag = 0;
            break;
        }
        scanf("%*c");
        if (a != 6) {
            getchar();
        }
        system("cls");
    }
    FreeLibrary(MyDLL);
    
    return 0;
    

    }

  4. Assistant

    Исключение, которое вы видите, вероятно вызвано ошибкой доступа к памяти, возникшей из-за неправильного использования указателей или вызова функций из динамической библиотеки. Рассмотрим основные проблемы в вашем коде и пути их исправления.


    Основные проблемы

    1. Неправильная обработка возвращаемых функций из библиотеки

    Вы используете функцию GetProcAddress, чтобы получить адрес экспортируемых функций из загруженной DLL:

    split split_string = GetProcAddress(MyDLL, "split_string");
    parse parse_data = GetProcAddress(MyDLL, "parse_data");
    write write_data = GetProcAddress(MyDLL, "write_data");
    find_avg find_average = GetProcAddress(MyDLL, "find_average");
    str_search string_search = GetProcAddress(MyDLL, "string_search");
    find_ln find_surname = GetProcAddress(MyDLL, "find_surname");
    

    Однако GetProcAddress возвращает указатель типа FARPROC (обычно void*), который необходимо привести к нужному типу функции вручную. Это типично работает в C, но если возникает неправильное приведение типа или ошибка при загрузке функции, программа может аварийно завершиться.

    Добавьте проверку на успешную загрузку каждой функции:

    split split_string = (split)GetProcAddress(MyDLL, "split_string");
    if (!split_string) {
        printf("Ошибка: не удалось загрузить функцию split_string из DLL\n");
        FreeLibrary(MyDLL);
        return 1;
    }
    
    parse parse_data = (parse)GetProcAddress(MyDLL, "parse_data");
    if (!parse_data) {
        printf("Ошибка: не удалось загрузить функцию parse_data из DLL\n");
        FreeLibrary(MyDLL);
        return 1;
    }
    
    // Аналогично остальные функции.
    

    Если GetProcAddress вернет NULL, это означает, что либо функции с указанным именем не существует в DLL, либо ее сигнатура/экспорт некорректны.


    2. Неправильная работа с параметрами и возвращаемыми значениями функции parse_data

    Функция parse_data возвращает массив пользователей (struct User), который выделен в памяти самой функции. Однако в коде:

    users = parse_data(current_read_path, &n);
    

    Вы не проверяете возвращаемую память, а также может быть некорректное количество данных.

    Добавьте проверку возврата функции перед использованием:

    struct User* temp_users = parse_data(current_read_path, &n);
    if (!temp_users) {
        printf("Ошибка: не удалось загрузить пользователей из файла %s\n", current_read_path);
    } else {
        free(users); // Освобождаем старую память (если она была)
        users = temp_users;
    }
    

    Если функция parse_data не выделяет динамическую память должным образом для структуры User, это может вызвать ошибки доступа к памяти (например, записи или чтения из несуществующих адресов).


    3. Неправильная работа с другими функциями (например, find_surname)

    Функция find_surname также возвращает динамически выделенную память (по крайней мере, это подразумевается). Однако в коде эта память также используется без проверки (например, отсутствие проверки на NULL).

    Добавьте аналогичные проверки:

    matches = find_surname(search_ln, users, n, &matches_n);
    if (!matches) {
        printf("Ошибка: совпадения не найдены или произошла ошибка.\n");
        matches_n = 0; // убедитесь, что количество совпадений обнулено
    } else {
        printf("Найдено совпадений: %d\n", matches_n);
    }
    

    4. Отсутствие освобождения динамической памяти

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

    • matches выделяется с помощью malloc, но не освобождается.
    • Аналогично для массива users.

    Добавьте освобождение при завершении программы:

    // Освобождаем массив пользователей
    if (users) {
        free(users);
    }
    
    // Освобождаем совпадения
    if (matches) {
        free(matches);
    }
    
    // Освобождаем библиотеку
    FreeLibrary(MyDLL);
    

    5. Предположение о корректной работе функций в DLL

    Функции, такие как parse_data, split_string, и т.д., импортируются из внешней библиотеки, но без проверки их корректности и поведения вы не можете гарантировать, что они возвращают корректные данные или работают с параметрами как ожидается.

    Пример: структура User предполагает наличие данных last_name, first_name, и т.д. Если функция parse_data вернет неинициализированную память, это может вызвать исключения при выводе.

    Добавьте базовую проверку:

    if (users[i].age < 0 || users[i].age > 150) {
        printf("Ошибка в данных пользователя: некорректный возраст.\n");
        continue;
    }
    

    6. Конфликт между Unicode (TCHAR) и char

    Вы используете TCHAR в некоторых местах (например, current_read_path), но остальной код работает с обычными char. Убедитесь, что строковые функции обрабатывают символы правильно:

    • В случае Unicode (TCHAR в режиме Unicode будет wchar_t), используйте функции для широких строк, такие как wcslen, wcscpy, и т.д.
    • Если вы компилируете в ANSI, замените TCHAR на char для упрощения.

    7. Предыдущий ввод блокирует текущий цикл (EOF или scanf)

    В некоторых случаях предыдущий ввод или неправильно обработанный буфер (getchar(), scanf) может повлиять на дальнейшую работу:

    Например:

    scanf("%*c"); // Не очищает буфер ввода полностью!
    getchar();    // Может вызвать блокировку при ожидании нового ввода после ошибки.
    

    Решение: добавьте очистку после каждой команды ввода:

    while (getchar() != '\n'); // Очищаем буфер ввода
    

    Общая структура с исправлениями

    Ваш код с исправлениями и основными проверками может выглядеть так:

    users = parse_data(current_read_path, &n);
    if (!users) {
        printf("Ошибка: данные не считаны\n");
        continue;
    }
    
    // Проверка вывода
    for (int i = 0; i < n; i++) {
        if (users[i].age < 0) {
            printf("Ошибка в данных пользователя\n");
            continue;
        }
        printf("Пользователь: %s %s, возраст: %d\n",
            users[i].first_name, users[i].last_name, users[i].age);
    }
    

    Свяжитесь с DLL-разработкой. Если сами функции в библиотеке работают некорректно, ошибки нужно исправлять внутри DLL.

  5. User

    Данное исключение возникает только при использовании функции parse_data extern "C" __declspec(dllexport) struct User* parse_data(TCHAR path[], int* n); struct User* parse_data(TCHAR path[], int* n) { HANDLE fh; DWORD dwcount;

    wprintf(L"%s", path);
    char buffer[N_BUFF];
    fh = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (fh == INVALID_HANDLE_VALUE)
    {
        printf("Не удалось открыть указанный файл");
        exit(-1);
    }
    if (!ReadFile(fh, buffer, sizeof(buffer) - 1, &dwcount, NULL)) {
        printf("Ошибка чтения данных из файла");
        exit(-1);
    }
    buffer[dwcount] = '\0';
    CloseHandle(fh);
    char* token = strtok(buffer, "\n");
    struct User* users = (struct User*)malloc(500 * sizeof(struct User));
    char** users_str = (char**)malloc(sizeof(char*) * 100);
    char** users_str1 = (char**)malloc(sizeof(char*) * 100);
    int i = 0;
    
    
    while (token != NULL) {
        users_str[i] = (char*)malloc(sizeof(char) * 200);
        strcpy(users_str[i], token);
        token = strtok(NULL, "\n");
        i++;
    
    }
    (*n) = i;
    for (int j = 0; j < i; j++) {
        printf("%s\n", users_str1[0]);
        printf("%s\n", users_str1[1]);
        printf("%s\n", users_str1[2]);
        printf("%s\n", users_str1[3]);
        users_str1 = split_string(users_str[j]);
        strcpy(users[j].last_name, users_str1[0]);
        strcpy(users[j].first_name, users_str1[1]);
        strcpy(users[j].patronymic, users_str1[2]);
        users[j].age = atoi(users_str1[3]);
    
    }
    return users;
    

    }

  6. Assistant

    Исходя из кода, проблема связана с использованием функции split_string или неправильной обработкой данных в функции parse_data. Разберем все возможные причины возникновения ошибки нарушения прав доступа (0xC0000005) в вашем коде:


    Потенциальные проблемы и их исправления:

    1. Перезапись указателя users_str1

    Вы динамически выделяете память для users_str1, но затем перезаписываете указатель этим участком кода:

    users_str1 = split_string(users_str[j]);
    

    После вызова split_string, значение users_str1 перезаписывается. Из-за этого любые операции, такие как:

    printf("%s\n", users_str1[0]);
    

    скорее всего, вызывают ошибку, потому что указатель users_str1 указывает в неизвестное место.

    Исправление: Разделите значение, возвращаемое split_string, в отдельный временный указатель:

    char** temp_users_str1 = split_string(users_str[j]);
    if (temp_users_str1 == NULL) {
        printf("Ошибка при разбиении строки.\n");
        continue;
    }
    

    2. Работа с функцией split_string

    Поведение функции split_string вам не показано в коде. Если эта функция:

    • Возвращает NULL;
    • Не создает корректно массив строк;
    • Ошибочно работает с памятью,

    то это приведет к нарушению прав доступа. Проверьте код функции split_string. Убедитесь, что она:

    1. Корректно выделяет массив строк.
    2. Возвращает не NULL при успешном выполнении.
    3. Завершает строки с '\0'.

    Пример ожидания соответствующего поведения:

    char** split_string(char* str) {
        // Реализация должна возвращать массив строк, завершающийся NULL
    }
    

    Проверка возвращаемого значения:

    char** temp_users_str1 = split_string(users_str[j]);
    if (temp_users_str1 == NULL) {
        printf("split_string вернул NULL. Пропускаем.\n");
        continue;
    }
    

    3. Чтение и обращение к users_str1 до вызова split_string

    В этой части кода:

    printf("%s\n", users_str1[0]);
    printf("%s\n", users_str1[1]);
    printf("%s\n", users_str1[2]);
    printf("%s\n", users_str1[3]);
    

    Вы пытаетесь обратиться к элементам users_str1 без инициализации. При этом users_str1 изначально указывает на необработанную память. Это вызывает ошибку доступа, так как вы пытаетесь получать значения из массива, который мог еще не быть выделен.

    Исправление: Переместите вывод сразу после вызова split_string и проверьте указатель:

    char** temp_users_str1 = split_string(users_str[j]);
    if (!temp_users_str1) {
        printf("Ошибка: split_string вернул NULL.\n");
        continue;
    }
    printf("%s\n", temp_users_str1[0]);
    printf("%s\n", temp_users_str1[1]);
    printf("%s\n", temp_users_str1[2]);
    printf("%s\n", temp_users_str1[3]);
    
    strcpy(users[j].last_name, temp_users_str1[0]);
    strcpy(users[j].first_name, temp_users_str1[1]);
    strcpy(users[j].patronymic, temp_users_str1[2]);
    users[j].age = atoi(temp_users_str1[3]);
    

    4. Размер массива users

    Вы выделяете фиксированную память под struct User:

    struct User* users = (struct User*)malloc(500 * sizeof(struct User));
    

    Если строк больше, чем 500, запись выходит за пределы выделенной памяти, что приводит к ошибкам при выполнении.

    Исправление: Убедитесь, что выделено достаточно памяти или используйте перераспределение:

    users = realloc(users, new_size * sizeof(struct User));
    

    5. Утечки памяти

    Если strtok обрабатывает строки некорректно, а память не освобождается, это также может привести к непредсказуемому поведению программы.

    Простой пример добавления освобождения памяти:

    for (int j = 0; j < i; j++) {
        free(users_str[j]);
    }
    free(users_str);
    
    // Если `temp_users_str1` нужно освободить:
    if (temp_users_str1 != NULL) {
        for (int k = 0; k < ...; k++) {
            free(temp_users_str1[k]);
        }
        free(temp_users_str1);
    }
    

    Результат с исправлениями

    Исправленный код функции parse_data:

    extern "C" __declspec(dllexport) struct User* parse_data(TCHAR path[], int* n) {
        HANDLE fh;
        DWORD dwcount;
    
        wprintf(L"%s", path);
        char buffer[N_BUFF];
        fh = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (fh == INVALID_HANDLE_VALUE) {
            printf("Не удалось открыть указанный файл\n");
            return NULL;
        }
    
        if (!ReadFile(fh, buffer, sizeof(buffer) - 1, &dwcount, NULL)) {
            printf("Ошибка чтения данных из файла\n");
            CloseHandle(fh);
            return NULL;
        }
        buffer[dwcount] = '\0';
        CloseHandle(fh);
    
        char* token = strtok(buffer, "\n");
        struct User* users = (struct User*)malloc(500 * sizeof(struct User));
        if (!users) {
            printf("Ошибка выделения памяти для пользователей.\n");
            return NULL;
        }
    
        char** users_str = (char**)malloc(sizeof(char*) * 100);
        if (!users_str) {
            printf("Ошибка выделения памяти для строк пользователей.\n");
            free(users);
            return NULL;
        }
    
        int i = 0;
        while (token != NULL) {
            users_str[i] = (char*)malloc(sizeof(char) * 200);
            if (!users_str[i]) {
                printf("Ошибка выделения памяти для строки.\n");
                break;
            }
            strcpy(users_str[i], token);
            token = strtok(NULL, "\n");
            i++;
        }
    
        (*n) = i;
    
        for (int j = 0; j < i; j++) {
            char** temp_users_str1 = split_string(users_str[j]);
            if (!temp_users_str1) {
                printf("Ошибка при разбиении строки.\n");
                continue;
            }
            printf("%s\n", temp_users_str1[0]);
            printf("%s\n", temp_users_str1[1]);
            printf("%s\n", temp_users_str1[2]);
            printf("%s\n", temp_users_str1[3]);
    
            strcpy(users[j].last_name, temp_users_str1[0]);
            strcpy(users[j].first_name, temp_users_str1[1]);
            strcpy(users[j].patronymic, temp_users_str1[2]);
            users[j].age = atoi(temp_users_str1[3]);
    
            // Освобождение temp_users_str1
            for (int k = 0; temp_users_str1[k] != NULL; k++) {
                free(temp_users_str1[k]);
            }
            free(temp_users_str1);
        }
    
        for (int j = 0; j < i; j++) {
            free(users_str[j]);
        }
        free(users_str);
    
        return users;
    }
    

    Главные моменты:

    1. Обязательно проверьте поведение и реализацию функции split_string.
    2. Всегда проверяйте указатели на NULL перед использованием.
    3. Добавляйте освобождение выделенной памяти.
    4. Убедитесь, что размер users и users_str не вызывает выход за пределы памяти.