C Zeichenketten und Speicher

[toboe (Gast)]

Hallo,

ich bin neu in der C-Programmierung, habe vorher nur in Java 
programmiert. Möchte gerne eine Datei zeilenweise auslesen und die 
Zeilen dann splitten. Mein bisheriger Code:

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


char  *read_line(FILE *);
char **split    (const char *, const char *, int *);


int main(int argc, char *argv[])
{
  if (argc != 2) {
    printf("input file expected.\n");
    return EXIT_FAILURE;
  }

  FILE *input_file = fopen(argv[1], "r");
  if (NULL == input_file) {
    printf("couldn't open file %s.\n", argv[1]);
    return EXIT_FAILURE;
  }

  while (feof(input_file) == 0) {
    char *line = read_line(input_file);
    printf("%s\t%d\n", line, strlen(line));

    int num_tokens = 0;
    char **tokens = split(line, " ", &num_tokens);

    for (int i = 0; i < num_tokens; ++i) {
      printf("Token #%d: %s\t(%d)\n", (i + 1), tokens[i], strlen(tokens[i]));
      free(tokens[i]);
    }

    free(tokens);
    free(line);
  }

  fclose(input_file);

  return EXIT_SUCCESS;
}


char *read_line(FILE *input_file)
{
  assert (NULL != input_file);

  char *buffer = malloc(sizeof(char));
  assert (NULL != buffer);

  int length = 1;
  int index  = 0;

  int read = fgetc(input_file);
  while (EOF != read && '\n' != read) {
    if (index >= length) {
      length *= 2;
      buffer = realloc(buffer, length * sizeof(char) + 1);
      assert (NULL != buffer);
    }
    buffer[index] = read;
    ++index;

    read = fgetc(input_file);
  }

  buffer[index] = '\0';
  return buffer;
}


char **split(const char *str, const char *delimiters, int *num_tokens)
{
  assert (NULL != str);
  assert (NULL != delimiters);
  assert (NULL != num_tokens);

  char *string = malloc(strlen(str) + 1);
  assert (NULL != string);
  strcpy(string, str);

  char **tokens = malloc(sizeof(char *));
  assert (NULL != tokens);

  int number_tokens = 1;
  int index = 0;

  char *token = strtok(string, delimiters);
  while (NULL != token) {
    if (index >= number_tokens) {
      ++number_tokens;
      tokens = realloc(tokens, number_tokens * sizeof(char *));
      assert (NULL != tokens);
    }
    tokens[index] = malloc(strlen(token) + 1);
    assert (NULL != tokens[index]);
    strcpy(tokens[index], token);

    ++index;
    token = strtok(NULL, delimiters);
  }

  *num_tokens = number_tokens;
  return tokens;
}

Es scheint zu funktionieren, wie ich es mir vorgestellt hatte. 
Allerdings bin ich mir unsicher, ob ich den Speicher "richtig und 
komplett" freigegeben habe. Insbesondere habe ich Bedenken bei der 
split-Funktion, ob ich dort "string" noch freigeben muss. strtok 
verändert "string" ja und liefert Zeiger aus selbigen zurück. Reicht es 
dann, wenn ich das jeweilige aktuelle Token freigebe und nicht "string" 
als Ganzes am Ende der Funktion?

Und eine kleine Frage nebenbei: Für diese Kleinigkeit wirkt mir das 
Programm ziemlich "aufgebläht", obwohl ich von Java komme. Gibt es eine 
elegante Implementation für diese Funktionalität?

Ich bin für jede Antwort dankbar.

[Klaus W. (mfgkw)]

toboe schrieb:
> strtok
> verändert "string" ja und liefert Zeiger aus selbigen zurück. Reicht es
> dann, wenn ich das jeweilige aktuelle Token freigebe und nicht "string"
> als Ganzes am Ende der Funktion?

Du darfast nur genau das freigeben, was du auch allokiert hast.

Also wenn du einen langen String allokierst und dann stückweise 
verarbeitest, musst du trotzdem genau den Stringanfang freigeben, das 
gilt dann für den gesamten Speicher wie er zuerst allokiert wurde.

Beim Versuch, stückweise freizugeben, was du in einem Rutsch allokiert 
hast, stürzt im besten Fall dein Programm ab.