C printf changer le contenu de la variable à l'intérieur de la fonction

Vous strcat quelque chose à buffer mais le buffer n'a jamais été initialisé. strcat recherchera d'abord le premier caractère nul, puis copiera la chaîne pour y concaténer. Vous écrasez probablement de la mémoire qui n'est pas la vôtre.

Avant la boucle externe while , faites:

    *buffer= '\0';

Sebastian, si vous rencontrez toujours des problèmes après la réponse @PaulOgilvie , il est fort probable que ce ne soit pas comprendre sa réponse. Votre problème est dû au fait que le buffer est alloué mais non initialisé . Lorsque vous appelez malloc , il alloue un bloc d'au moins la taille demandée, et renvoie un pointeur vers l'adresse de début du nouveau bloc - mais ne fait rien avec le contenu du nouveau bloc - ce qui signifie que le bloc est composé de valeurs aléatoires complètes qui se trouvent juste dans la plage d'adresses du nouveau bloc.

Donc, lorsque vous appelez strcat (buffer, current_char_str); le la première fois et il n'y a rien d'autre que des déchets aléatoires dans buffer et pas de caractère nul-terminating - vous appelez Undefined Behavior . (il n'y a pas de fin de chaîne dans buffer à trouver)

Pour corriger l'erreur, il vous suffit de créer un buffer an chaîne-vide après avoir été allouée en définissant le premier caractère sur le caractère nul-terminating , ou utilisez plutôt calloc pour allouer le bloc qui garantira tout les octets sont mis à zéro.

Par exemple:

> parsepath2.exe another/path/that/ends/in/a/filename
buffer (another)
buffer (path)
buffer (that)
buffer (ends)
buffer (in)
buffer (a)
buffer (filename)
hello

De même, ne codez pas en dur les chemins ou les nombres (qui inclut le 0 et 2 , mais nous les laisserons glisser pour l'instant). Le codage en dur "this / is / a / path / hello" dans parse_path () make est une fonction plutôt inutile. Au lieu de cela, faites de votre variable chemin votre paramètre afin que je puisse prendre n'importe quel chemin que vous voulez lui envoyer ...

Alors que toute l'idée de réallouer «Avoir 2 caractères à la fois est plutôt inefficace, vous devez toujours réallouer avec un pointeur temporaire plutôt que le pointeur lui-même. Pourquoi? realloc peut échouer et échoue et quand il le fait, il renvoie NULL . Si vous utilisez le pointeur lui-même, vous écraserez votre adresse de pointeur actuelle par NULL en cas d'échec, perdant l'adresse de votre bloc de mémoire existant pour toujours créer une fuite de mémoire. Au lieu de cela,

> parsepath2.exe
buffer (this)
buffer (is)
buffer (a)
buffer (path)
buffer (hello)
hello

Un court exemple incorporant les correctifs et le pointeur temporaire serait:

#include <stdio.h>
#include <limits.h>  /* for PATH_MAX - but VS doesn't provide it, so we check */

#ifndef PATH_MAX
#define PATH_MAX  2048
#endif

void parse_path (const char *pathname)
{
    const char *p = pathname;
    char buffer[PATH_MAX], *b = buffer;

    while (*p) {
        if (*p == '/') {
            if (p != pathname) {
                *b = 0;
                printf ("buffer (%s)\n", buffer);
                b = buffer;
            }
        }
        else
            *b++ = *p;
        p++;
    }
    if (b != buffer) {
        *b = 0;
        printf ("buffer (%s)\n", buffer);
    }
}

int main (int argc, char* argv[]) {

    char *path = argc > 1 ? argv[1] : "this/is/a/path/hello";
    parse_path (path);
    printf ("hello\n");

    return 0;
}

( remarque: votre logique est assez torturée ci-dessus et vous pouvez simplement utiliser un tampon fixe de taille PATH_MAX (y compris limits.h ) et vous dispenser d'allouer. Sinon, vous devriez allouer un certain nombre de caractères prévu pour le buffer pour commencer, comme strlen (chemin) qui assurerait un espace suffisant pour chaque composant de chemin sans réallouer. Je préfère surallouer par 1000 caractères que foutre l'indexation se soucier de la réattribution de 2 caractères à la fois ...)

Exemple d'utilisation / sortie

> bin\parsepath.exe
buffer(this)
buffer(is)
buffer(a)
buffer(path)
buffer(hello)
hello