leerzeichen aus string löschen

nieselfriem

hallo wir haben die Aufgabe ein Leerzeichen aus einem String zu löschen. eigentlich nicht schwer dachte ich. da ich aber mit c bzw c++ nicht die erfahrung habe stellt sich die sache doch schwieriger dar als ich dachte.
hier mal men code

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

void loesche(char* e) 
{
 int i=0,s=0;
 int length = 0;
 string str=base;
 while(e[length] != '\0')
   length++;

 for(i;i<length-1;i++) 
 {
    printf("e [i]=%c\n",e[i]);
    if (e[i]==' ')
    {
       e[i]='';  //hier schein ein problem zu geben                   
    }
 }

 printf("e=%s,s=%d\n",e,length);
}

int main(int argc, char argv[])
{
  const int MAXLEN = 1024;  // maximale Laenge der Eingabe
  char eingabe[MAXLEN];     // Fuer die Eingabe
  printf("Eingabe? ");
  gets(eingabe);
  loesche(eingabe);
  printf("\nEingabe ohne Leerzeichen :\"%s\"\n",eingabe);
}

statt den string nun zusammen auszugeben kommt es zu folgender ausgabe

Eingabe ohne Leerzeichen :"sdsd↕sdsd"

gruß niesel

Nagila Hawa

Moin!

Du entfernst das Leerzeichen (' ') in deinem Programm nicht, sondern ersetzt es durch ein anderes Zeichen (''). Du müsstest alle Zeichen hinter dem Leerzeichen um ein Feld nach links verschieben.

Du müsstest alle Zeichen hinter dem Leerzeichen um ein Feld nach links verschieben.

Und das wäre ein schlechte Sache.

Einfacher geht das ganze mit verketteten Listen.
Aus denen kann man Elemente löschen ohne den ganzen Rest
verschieben zu müssen.

Ich hab dir ein Beispiel zusammengefrickelt:

#include <stdio.h>

typedef struct pair {
    char car;
    struct pair *cdr;
} pair_t;

#define set_car(pair, what) (pair->car = what)
#define set_cdr(pair, what) (pair->cdr = what)
#define car(pair) (pair->car)
#define cdr(pair) (pair->cdr)

pair_t *cons(char car, pair_t *cdr)
{
    /* malloc könnte schiefgehen -- mir egal */
    pair_t *pt = malloc(sizeof(*pt));
    pt->car = car;
    pt->cdr = cdr;
    return pt;
}

int length(pair_t *pt)
{
    int i;
    for (i = 0; pt; i++, pt = cdr(pt))
        ;
    return i;
}

pair_t *string2list(char *str)
{
    pair_t *pt = NULL;
    char *walk = str + strlen(str) - 1;

    for ( ; walk >= str; walk--)
        pt = cons(*walk, pt);
    return pt;
}

char *list2string(pair_t *pt)
{
    int l = length(pt);
    /* malloc könnte schiefgehen -- mir egal */
    char *buf = malloc(l + 1);

    for ( ; pt; pt = cdr(pt), buf++)
        *buf = car(pt);
    *buf = '\0';
    return buf - l;
}

void destroy_list(pair_t *pt)
{
    pair_t *next = NULL;

    if (!pt) return;
    next = pt->cdr;
    free(pt);
    destroy_list(next);
}

void remove_chars(pair_t *pt, char c)
{
    pair_t *to_free = NULL;

    if (!cdr(pt))
        return;
    else if (car(cdr(pt)) == c) {
        to_free = cdr(pt);
        set_cdr(pt, cdr(cdr(pt)));
        free(to_free);
    }
    remove_chars(cdr(pt), c);
}

int main(int argc, char *argv[])
{
    pair_t *p = string2list("ich hasse whitespace");
    char *new_string;

    remove_chars(p, ' ');
    new_string = list2string(p);
    destroy_list(p);

    printf("%s\n", new_string);

    free(new_string);
    return 0;
}

Und wer bis hierher gelesen hat, darf über Lisp schimpfen.

vlad_tepesch

es ist wohl heffentlich nicht dein Ernst, dass du strings als verkettete listen speichern willst.

hab ich jetzt mal schnell zusammengehackt, können also noch fehler drin sein.

/** 
 *  copys all non-space-characters into o_string
 *  @param i_string  input string
 *  @param o_string  To this will be the output written, so ensure it is enough free space in string. 
 `*                  May be NULL. May be the same as i_string.
 *  @returns length of new o_string. If o_string is NULL then the only the number of chars required in o_string is returned.
 *           This length does not include the terminating '\0'-character. 
 */
unsigned int killSpaces( const char* i_string, char* o_string)
{
  unsigned int len = strlen(i_string);
  unsigned int pos = 0;
  unsigned int i;
  if( o_string == NULL )
  {
    for( i=0; i<len; ++i)
    {
      if(  i_string[i] != ' ' )
      {
        ++pos;
      }
    }
  }else{
    for( i=0; i<len; ++i)
    {
      if(  i_string[i] != ' ' )
      {
        o_string[pos] = i_string[i];
        ++pos;
      }
    }
    o_string[pos] = 0; /* string terminieren */
  }
  return pos;
}

Da gab's erst letztens einen Thread: http://www.c-plusplus.net/forum/viewtopic-var-p-is-1629464.html

es ist wohl heffentlich nicht dein Ernst, dass du strings als verkettete listen speichern willst.

Alles schon passiert.
Wäre bei vernünftigem Scheme-Compiler btw nicht weiter schlimm.

Ich wollte dich ja noch ärgern, aber Tim hat dir schon verraten,
daß sogar o_string unnötig ist.

Und das wäre ein schlechte Sache.

Da war ich zugegebener Weise in einer ganz anderen Welt...

vlad_tepesch

flamer schrieb:

es ist wohl heffentlich nicht dein Ernst, dass du strings als verkettete listen speichern willst.

Alles schon passiert.
Wäre bei vernünftigem Scheme-Compiler btw nicht weiter schlimm.

Scheme ist ja in erster line ein didaktisches Mittel. Da ist Performance und Speicherbelegung nicht so wichtig.

Zum Thema Scheme fällt mir das wieder ein:
http://xkcd.com/224/ <-- der tooltip über dem Comicstrip ist auch geil
(Scheme ist eine Lisp-Abart)

flamer schrieb:

Ich wollte dich ja noch ärgern, aber Tim hat dir schon verraten,
daß sogar o_string unnötig ist.

sagt ja auch der Kommentar, dass beides die selbe Variable sein kann.

Scheme ist ja in erster line ein didaktisches Mittel. Da ist Performance und Speicherbelegung nicht so wichtig.

LOL. Sag das mal denen.
Ich habe schreibe seit längerem alle halbwegs wichtigen Programme in R5RS.
Die Performance solltest du vielleicht testen, bevor du sie "nicht so wichtig" nennst.

alt schrieb:

We lost the documentation on quantum mechanics. You'll have to decode the regexes yourself.

Das ist einer meiner Gründe.

sagt ja auch der Kommentar, dass beides die selbe Variable sein kann.

Stimmt, hatte ich übersehen.
Sorry!