chatGPT – C-Programmierung Linux Windows plattformübergreifend – Codeüberprüfungsanfrage

Ich habe mich mit der Verwendung von chatGPT-Eingabeaufforderungen zum Programmieren in C beschäftigt.

Durch die Verwendung inkrementeller Eingabeaufforderungen ist es möglich, dass chatGPT 3.5 viel mehr leistet als erwartet.

Ich wundere mich über die Codequalität und würde mich über Feedback sowohl zu Eingabeaufforderungen als auch zum Code freuen.

Funktionsziel

• Überprüfen Sie, ob ein Pfad gültig ist, und analysieren Sie die Pfadkomponenten
• Plattformübergreifende Kompatibilität mit MacOS Linux Windows

Durchführung

Thread-sicherer Code
statischer Pfad
dynamische Pfadzuweisung für größere Pfadzeichenfolge

Standardpraxis für Linux/MacOs ist die dynamische Zuweisung (4095/1024 Diagrammpfadlimit), während Windows (260 Pfadlimit) die statische Zuweisung erfolgt.

Prompt

Ich baue die Abfrage schrittweise auf, sonst neigt chatGPT dazu, frühere Anforderungsänderungen zu verlernen.

Letztendlich sieht das aus wie eine grobe Form der Metakodierung, bei der es möglich ist, den LLM zu zwingen, den gewünschten Code zu generieren.

_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

Der Code wird Feature für Feature so gestaltet, dass er dem gewünschten Stil entspricht

modify example 
replace 60 by equate

Einige Eingabeaufforderungen blieben hängen, ohne dass sie wiederholt wurden. „no WSL cygwin“ wurde schon früh hinzugefügt, um zur Eingabe von Windows-Betriebssystem-spezifischem Code aufzufordern, und dann gelöscht.

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

Code

Der resultierende Code wird beim ersten Mal kompiliert und ausgeführt.

#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.

Das obige ist der detaillierte Inhalt vonchatGPT – C-Programmierung Linux Windows plattformübergreifend – Codeüberprüfungsanfrage. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!