Stringteilung in C

[M. V. (bmtil)]

Hallo, ich hab ein kleines Problem.
Im folgendem Programmstueckchen sollen Strings (als str_in bezeichnet) 
nach einem Leerezeichen durchsucht werden und an der Stelle von diesem 
in str_1 und str_2 geteilt werden.
Das Problem ist, ich weiss nicht wie ich die Abbruchbedinung formulieren 
soll, falls in dem str_in kein Leerzeichen vorhanden ist.
Hier ist der Code:

char str_in[10];
char str_1 [10];
char str_2  [10];


void subset()
{  
  char index_in, index_out;
  
  index_in = 0;
  index_out = 0;
  
  while (str_in[index_in] != 0x20 && str_in[index_in]==0)
  {
    str_1[index_out] = str_in[index_in];
    index_in++;
    index_out++;
  }
  
  index_out = 0;
  
  while (str_in[index_in] != 0x0A && str_in[index_in] != 0x0D)
  {
    str_2[index_out] = str_in[index_in];
    index_in++;
    index_out++;
     }
   
}

[Bedingung (Gast)]

In beiden Schleifen "&& index_in <= 9" hinzufuegen

MfG

[HP (Gast)]

ist der String 0-Terminiert? Wenn ja, wäre das deine Abbruchbedingung. 
ansonsten kannst du ja nach der maximalen Länge des Stings (hier 10) 
abbrechen. Weiter darfst du ohnehin nicht gehen

[M. V. (bmtil)]

Bedingung schrieb:
> In beiden Schleifen "&& index_in <= 9" hinzufuegen
>
> MfG

Das funktioniert leider nicht.
Ich sollte noch erwaehnen dass ich mit Strings von unbestimmter Länge 
arbeite.

[(Ein) (Gast)]

Du könntest es auch mit index() und strtok() etc. probieren. Oder 
einfach auf '\0' prüfen, das ist das Ende des Strings (siehe Beitrag von 
HP)...

[M. V. (bmtil)]

Enmtschuldigung für den Doppelpost,
das war doch die Lösung, ich hab bloss bei der Variablen Deklaration die 
eckigen Klammern vergessen,
Vielen dank.

[Random .. (thorstendb)]

mjam, Spielchen :-)

mal eben schnell runtercodiert, sollte funktionieren:

#define TOKEN     ' '
#define MAX_STR    16

int Tokenizer(char *str, char **dest, char token)
{
  unsigned int cnt=0, i=0;

  if(!str || !dest) return(-1);

  do {
    i++;
    if(*str == token) {
      dest[cnt] = (char *) malloc ((i * sizeof(char)) +1);
      memcpy(dest[cnt], str-(i-1), (i-1));
      dest[cnt++][(i-1)] = 0;
      if(cnt > (MAX_STR-1)) return(-1);
      i=0;
    }
  } while(*str++);

  if(cnt > (MAX_STR-1)) return(-1);
  dest[cnt] = (char *) malloc ((i * sizeof(char)) +1);
  memcpy(dest[cnt], str-i, i);
  dest[cnt++][i] = 0;

  return(cnt);
}


int main()
{
  char *str = "Hallo, Welt. Dies ist ein Test zum Tokenizer.";
  char *dest[MAX_STR];
  int strs;
  
  strs = Tokenizer(str, dest, TOKEN);
}

Viel Spass damit!

[Mark B. (markbrandis)]

Random ... schrieb:
> mal eben schnell runtercodiert, sollte funktionieren

Tut es :-)
Eine Ausgabe mit

  printf("str = %s\n", str);
  
  for(i=0; i<strs; i++)
  printf("dest[%d] = %s\n", i, dest[i]);

ergibt:

str = Hallo, Welt. Dies ist ein Test zum Tokenizer.
dest[0] = Hallo,
dest[1] = Welt.
dest[2] = Dies
dest[3] = ist
dest[4] = ein
dest[5] = Test
dest[6] = zum
dest[7] = Tokenizer.

[Random .. (thorstendb)]

:-)

vergesst das free() nicht, wenn's nicht mehr gebraucht wird, oder ein 
neuer String zerlegt werden soll, sonst gibtz memory leaks :-)

int i;
for(i=0; i<strs; i++) {
  free(dest[i]);
}

[Raff (Gast)]

versuchs mal damit:

/* ------------------------------------------------------------------------- *
 * Splits up string into tokens                                              *
 * ------------------------------------------------------------------------- */
static __inline__ void strtokenize(char *p, int *argc, char *argv[]) {

  for(*argc = 0;;) {

    /* skip all spaces and tabstops */
    while(*p == ' ' || *p == '\t')
      *p++ = '\0'; /* set them to zero */

    /* if string terminator occurs, we got no more tokens */
    if(*p == '\0') break;

    if(*p == ':') {
      /* the rest is a single argument
         can include blanks also */
      argv[(*argc)++] = p + 1;
      break;
    } else {
      /* add to argv list */
      argv[(*argc)++] = p;

      /* we reached maximal size of argv array */
      if(*argc == MAXARGS) break;

      /* scan for end of string, either ' ' or '\0' */
      while(*p != ' ' && *p != '\0')
        p++;
    }
  }

  /* null terminate argv list */
  argv[*argc] = NULL;
}