chatGPT - Pengaturcaraan C Linux Windows merentas platform - permintaan semakan kod

Saya telah campur tangan menggunakan gesaan chatGPT untuk memprogram dalam C.

Menggunakan gesaan tambahan adalah mungkin untuk mendapatkan chatGPT 3.5 untuk melakukan lebih banyak daripada yang dijangkakan.

Saya tertanya-tanya tentang kualiti kod dan akan menikmati maklum balas mengenai gesaan dan kod.

Objektif fungsi

• sahkan laluan adalah sah dan huraikan komponen laluan
• keserasian merentas platform Windows MacOS Linux

Perlaksanaan

kod selamat benang
laluan statik
peruntukan laluan dinamik untuk rentetan laluan yang lebih besar

Amalan standard untuk Linux / MacO ialah memperuntukkan secara dinamik (had laluan carta 4095 / 1024), manakala Windows (had laluan 260) adalah untuk memperuntukkan secara statik.

Prompt

Saya membina pertanyaan secara berperingkat, jika tidak, chatGPT cenderung untuk tidak mengetahui perubahan permintaan sebelumnya.

Akhirnya ini kelihatan seperti bentuk pengekodan meta yang kasar di mana adalah mungkin untuk memaksa LLM menjana kod yang dikehendaki.

_query
    LLM perplexity.ai

Modify code example
  Portable Path Parsing and Validation Code in C
    use thread safe function
      use function pointer
        strtok_s() for Windows
        strtok_r() for linux
allocate INITIAL_BUFFER_SIZE 60 char static path_copy
  declare pointer pfinal_path_copy initialize to path_copy
      when necessary
          dynamically allocate final_path_copy
          pfinal_path_copy = final_path_copy
use single strcpy(pfinal_path_copy, path) function

Kod dibentuk satu ciri pada satu masa untuk dipadankan dengan gaya yang diingini

modify example 
replace 60 by equate

Sesetengah gesaan kekal melekat tanpa diulang. "tiada WSL cygwin" telah ditambahkan lebih awal untuk menggesa kod khusus Windows OS, kemudian digugurkan.

write code example
 parse path in portable way
    linux windows MacOS
        no WSL cygwin

Kod

Kod yang terhasil dikompilasi dan dijalankan pada langkah pertama.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef _WIN32
#include <io.h>  // For _access() on Windows
#include <windows.h> // For Windows API
#else
#include <unistd.h>  // For access() on Unix-like systems (Linux, macOS)
#include <sys/stat.h>
#endif

// Define a constant for the initial buffer size
#define INITIAL_BUFFER_SIZE 60

// Function to check if a path is valid
int path_validate(const char *path) {
#ifdef _WIN32
    return _access(path, 0) == 0; // 0 means the file exists
#else
    struct stat buffer;
    return (stat(path, &buffer) == 0); // Returns 1 if valid, 0 if invalid
#endif
}

// Type definition for tokenization function pointer
typedef char* (*tokenizer_func)(char*, const char*, char**);

// Function to parse the path into components
void parse_path(const char *path) {
    char path_copy[INITIAL_BUFFER_SIZE]; // Static buffer for initial use
    char *final_path_copy = NULL; // Pointer for dynamic allocation
    char *pfinal_path_copy = path_copy; // Pointer to point to either path_copy or final_path_copy

    // Check if the input path length exceeds INITIAL_BUFFER_SIZE
    if (strlen(path) + 1 > INITIAL_BUFFER_SIZE) {
        final_path_copy = malloc(strlen(path) + 1); // Dynamically allocate memory
        if (final_path_copy == NULL) {
            fprintf(stderr, "Memory allocation failed.\n");
            exit(EXIT_FAILURE);
        }
        pfinal_path_copy = final_path_copy; // Point to dynamically allocated memory
    }

    // Use a single strcpy function to copy the path into the appropriate buffer
    strcpy(pfinal_path_copy, path); // Copy full path into the selected buffer

    // Determine the separator based on the platform and assign the tokenizer function
    const char *separator;
    tokenizer_func tokenizer;
    char *saveptr;

#ifdef _WIN32
    separator = "\";
    tokenizer = strtok_s; // Use strtok_s for Windows
#else
    separator = "/";
    tokenizer = strtok_r; // Use strtok_r for Linux
#endif

    // Tokenize using the assigned tokenizer function
    char *token = tokenizer(pfinal_path_copy, separator, &saveptr);

    while (token != NULL) {
        printf("Path component: %s\n", token);
        token = tokenizer(NULL, separator, &saveptr); // Continue tokenizing
    }

    free(final_path_copy); // Free dynamically allocated memory after use (if allocated)
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <path>\n", argv[0]);
        return EXIT_FAILURE;
    }

    const char *path = argv[1];

    // Validate the path using the new function name
    if (path_validate(path)) {
        printf("The path '%s' is valid.\n", path);
        printf("Parsing components:\n");
        parse_path(path);
    } else {
        printf("The path '%s' is invalid.\n", path);
    }

    return EXIT_SUCCESS;
}

## Unit test

Was created but not included here

## Performance

The entire exercise took 2:30 hour.
I have not tested the code on Windows or MacOS.
I'd like some feedback on code quality.

Atas ialah kandungan terperinci chatGPT - Pengaturcaraan C Linux Windows merentas platform - permintaan semakan kod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!