Vous devez seulement appeler gratuit () code> sur des pointeurs retournés par malloc () code>, calloc () code> ou realloc () code>. On dirait que vous faites:

home
or
for

Ce n'est pas un analyseur, cependant. Plus un tokenizer.

#include <assert.h>
#include <errno.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

bool parser(char const *str, char ***words, size_t *num_words, size_t *error)
{  //                             ^^^ gaaaah! *)
    assert(words);

    errno = 0;
    size_t length = strlen(str);

    for (size_t i = 0; i < length; ++i) {
        if (!isalnum(str[i]) && !isspace(str[i])) {
            *error = i;    // the position is most likely more meaningful than the character
            return false;  // get outta here!!
        }
    }

    char const *begin;
    char const *end;

    *num_words = 0;
    *words = NULL;

    bool in_word = false;
    for (size_t i = 0; i <= length; ++i) {
        if (!in_word && isalnum(str[i])) {  // word begins
            begin = str + i;
            in_word = true;
        }
        else if (in_word && !isalnum(str[i])) {  // word ended
            end = str + i;
            char *word = calloc(end - begin + 1, sizeof *word);
            if (!word) {
                for (size_t i = 0; i < num_words; ++i)
                    free((*words)[i]);
                free(*words);
                errno = ENOMEM;
                return false;               
            }

            memcpy(word, begin, end - begin);

            char **tmp = realloc(*words, (*num_words + 1) * sizeof *tmp);
            if (!tmp) {
                free(word);
                for (size_t i = 0; i < num_words; ++i)
                    free((*words)[i]);
                free(*words);
                errno = ENOMEM;
                return false;               
            }
            *words = tmp;
            tmp[(*num_words)++] = word;
            in_word = false;
        }
    }

    return true;
}

int main(void)
{
    char const *foo = "slfkja     askdfj jk j aksjf lasjdflkjsdlf jask fdjl";
    char **words = NULL;
    size_t num_words = 0;
    size_t error = 0;
    if (!parser(foo, &words, &num_words, &error)) {
        if (errno == ENOMEM)
            fputs("Not enough memory. :(\n\n", stderr);
        else fprintf(stderr, "Error at position %zu: \"%s\"\n\n", error, foo + error);
        return EXIT_FAILURE;
    }

    puts("List of words:");
    for (size_t i = 0; i < num_words; ++i) {
        printf("\"%s\"\n", words[i]);
        free(words[i]);
    }
    free(words);
}

C devrait être renommé brainf * ck ...

^{*) Programmeur trois étoiles}

1. vous modifiez la valeur de str dans le corps de la fonction (dans la ligne str = new; (n'utilisez pas new < / code> comme identifiant, plus si vous prévoyez d'utiliser ce code comme code C ++, car new est un mot réservé en C ++). Comme vous n'appelez pas malloc (3) < / code> dans le corps de la fonction, il est tout à fait normal que vous rencontriez un problème de free (3) , car free nécessite de passer un pointeur précédemment généré avec malloc (et uniquement une fois, vous ne pouvez donc pas l'appeler deux fois avec le même pointeur). C'est la raison pour laquelle vous obtenez SIGABRT et autres. En règle générale, n'appelez pas free (3) < / code> dans une fonction que vous n'appelez pas également malloc pour le même pointeur . Cette utilisation est sujette à des erreurs et vous rencontrerez des problèmes plus d'une fois par jour si vous insistez pour tout faire en un seul fonction.

2. mieux que de s'excuser pour la forme désordonnée du code, veuillez le nettoyer avant de poster Publiez un minimu (c'est-à-dire le code minimum qui montre l'erreur), complet (ce qui signifie que nous pouvons le compiler et observer le résultat que vous publiez comme un échec), vérifiable (code qui montre qu'il produit le résultat observé, et non celui attendu) et complet (cela signifie que nous n'avons rien d'autre à faire que de le compiler et de l'exécuter) du code (afin que nous puissions le tester en échec comme vous le dites, sans avoir à le corriger au préalable) De cette façon, nous pouvons faire un diagnostic de ce qui se passe dans votre code. Si nous devons corriger le code juste pour le rendre exécutable, nous pouvons corriger le problème principal que vous observez et ne pas voir l'erreur. Vous voyez? :)