Bestimmte Zeichen aus String entfernen? GCC

[Jan H. (janiiix3)]

Nabend,

Wie oben erwähnt würde Ich gerne aus einem String bestimmte Zeichen raus 
löschen und die Zeichen die danach kommen, hinten an den String wieder 
anfügen, so daß dort keine Leerzeichen entstehen.

Test String: Gutxxen Axxxbend
Ziel String: Guten Abend

Was macht man jetzt am besten? Man könnte es ja einfach umkopieren mit 
ein paar abfragen in ein anderes Array..

Gibt es noch eine gute Alternative?

[Kolja L. (kolja82)]

Unerwünschte Zeichen lösche ich meist mit der langen Taste üner der 
Return Taste auf der Tastatur.
Wenn du willst, dass dies eine Software macht, musst du schon sagen 
welche.

[Jan H. (janiiix3)]

Ohja..

Es geht um Gcc.

[A. S. (Gast)]

Schau dir einen Quellcode von strcpy an und kopiere nur wenn gewollt..

[Dr. Sommer (Gast)]

#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>

int main () {
  std::string str ("Gutxxen Axxxbend");
  std::cout << "Vorher: " << str << std::endl;
  str.erase (std::remove (begin (str), end (str), 'x'), end (str));
  std::cout << "Nachher: " << str << std::endl;
}

Ausgabe:

Vorher: Gutxxen Axxxbend
Nachher: Guten Abend

[Jan H. (janiiix3)]

Dr. Sommer schrieb:
> #include <iostream>
> #include <string>
> #include <algorithm>
> #include <iterator>
>
> int main () {
>   std::string str ("Gutxxen Axxxbend");
>   std::cout << "Vorher: " << str << std::endl;
>   str.erase (std::remove (begin (str), end (str), 'x'), end (str));
>   std::cout << "Nachher: " << str << std::endl;
> }
> Ausgabe:Vorher: Gutxxen Axxxbend
> Nachher: Guten Abend

Das ist C++

[Dr. Sommer (Gast)]

Jan H. schrieb:
> Das ist C++
Gut beobachtet... Und?

[Jan H. (janiiix3)]

Gibt es diese Funktionen in reinem C überhaupt?

[Dr. Sommer (Gast)]

Jan H. schrieb:
> Gibt es diese Funktionen in reinem C überhaupt?
Nö, aber wer redet von C?

[Axel S. (a-za-z0-9)]

Du meine Güte, das ist doch nun wirklich keine Raketenwissenschaft. 
Offensichtlich mußt du Zeichen für Zeichen durch den String gehen und 
unerwünschte Zeichen überspringen. Du kannst noch überlegen, ob du das 
Ergebnis in einen neuen String kopierst oder gleich den alten String 
überschreibst.

[Jan H. (janiiix3)]

Axel S. schrieb:
> Du meine Güte, das ist doch nun wirklich keine Raketenwissenschaft.
> Offensichtlich mußt du Zeichen für Zeichen durch den String gehen und
> unerwünschte Zeichen überspringen. Du kannst noch überlegen, ob du das
> Ergebnis in einen neuen String kopierst oder gleich den alten String
> überschreibst.

Ich will den alten String benutzen. Möchte ihn aber nicht überschreiben.

Die Zeichen sollen gelöscht werden die unerwünscht sind und jeweils soll 
kein Leerzeichen dazwischen stehen, also sollten die Zeichen die danach 
kommen nach links verschoben werden.

[Vril (Gast)]

Jan H. schrieb:
> Dr. Sommer schrieb:
>> #include <iostream>
>> #include <string>
>> #include <algorithm>
>> #include <iterator>
>>
>> int main () {
>>   std::string str ("Gutxxen Axxxbend");
>>   std::cout << "Vorher: " << str << std::endl;
>>   str.erase (std::remove (begin (str), end (str), 'x'), end (str));
>>   std::cout << "Nachher: " << str << std::endl;
>> }
>> Ausgabe:Vorher: Gutxxen Axxxbend
>> Nachher: Guten Abend

OMG!

schon mal was von 'regular expressions' gehört?

[Dr. Sommer (Gast)]

Nö, ist mir gänzlich neu, ich kenn nur kontextfreie Grammatiken.

[Frank M. (ukw) (Moderator)]

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

// 1. Loeschen durch Kopieren:
void remove_1 (char * target, const char * str, int maxlen)
{
    while (*str && maxlen)
    {
        if (*str != 'x')
        {
            *target++ = *str;
            maxlen--;
        }
        str++;
    }
    *target = '\0';
}

// 2. Loeschen direkt im String:
void remove_2 (char * str)
{
    char * p;

    while (*str)
    {
        while (*str == 'x')
        {
            for (p = str; *p; p++)
            {
                *p = *(p + 1);
            }
        }
        str++;
    }
}

int main ()
{
    char s[64];
    char t[64];

    strcpy (s, "Gutenxxx Tagxxx");
    remove_1 (t, s, 63);
    printf ("%s -> %s\n", s, t);

    remove_2 (s);
    printf ("%s\n", s);
    return 0;
}

$ cc rem.c -o rem && ./rem
Gutenxxx Tagxxx -> Guten Tag
Guten Tag

[Jan H. (janiiix3)]

Frank M. schrieb:
> void remove_2 (char * str)
> {
>     char * p;
>
>     while (*str)
>     {
>         while (*str == 'x')
>         {
>             for (p = str; *p; p++)
>             {
>                 *p = *(p + 1);
>             }
>         }
>         str++;
>     }
> }

Und wenn Ich jetzt..

Guxten Txag

Das die x entfernt werden und der Text danach jeweils um eins verschoben 
nach links rückt? Geht damit nicht?

[Dr. Sommer (Gast)]

Drei Schleifen ineinander?! Das geht einfacher:

#include <stdio.h>
#include <stddef.h>

size_t remove_2 (char* str, size_t n) {
  size_t i, j;
  for (i = 0, j = 0; j < n; ++j)
    if (str[j] != 'x')
      str[i++] = str[j];
  return i;
}

int main () {
  char str [] = "Gutenxxx Tagxxx";
  printf ("Vorher : %s\n", str);
  str [remove_2 (str, sizeof (str))] = 0;
  printf ("Nachher: %s\n", str);
}

[Frank M. (ukw) (Moderator)]

Jan H. schrieb:
> Das die x entfernt werden und der Text danach jeweils um eins verschoben
> nach links rückt? Geht damit nicht?

Der Text wird doch nach links verschoben. Probiers einfach aus oder gehe 
das Programm mit Bleistift und Papier schrittweise durch.

Ein wenig den eigenen Grips anstrengen muss man beim Programmieren (oder 
beim Programm-Lesen) schon. Wenn Dich das jetzt überfordert, schnapp dir 
ein C-Buch und arbeite es systematisch durch. Pointer sind nicht das 
erste, was man bei C lernen sollte.

[Michael B. (laberkopp)]

Dr. Sommer schrieb:
> Drei Schleifen ineinander?! Das geht einfacher:

Das ist doch dasselbe wie remove_1, nicht bemerkt ?

[Frank M. (ukw) (Moderator)]

Dr. Sommer schrieb:
> Das geht einfacher:

Einfacher gehts immer. Ich wollte eine möglichst auch für den Anfänger 
gut lesbare und nachvollziehbare Möglichkeit aufzeigen. ;-)

Da der TO aber zerstöungsfrei kopieren möchte, ist remove_1() sowieso 
die für ihn geeignetere Lösung.

[Dr. Sommer (Gast)]

Michael B. schrieb:
> Das ist doch dasselbe wie remove_1, nicht bemerkt ?
Hmm stimmt, remove_2 ist wohl generell überflüssig, man kann remove_1 
auch zweimal den gleichen Pointer übergeben sodass es in-place 
arbeitet...

[Emma W. (Gast)]

Dr. Sommer schrieb:
> Das geht einfacher:

Jan H. schrieb:
> Ich will den alten String benutzen. Möchte ihn aber nicht überschreiben.

[Frank M. (ukw) (Moderator)]

Dr. Sommer schrieb:
> Hmm stimmt, remove_2 ist wohl generell überflüssig,

Ja, remove_2() sollte lediglich eine Alternative aufzeigen, die der TO 
aber so gar nicht braucht, da er den Original-String nicht zerstören 
möchte.

[Axel S. (a-za-z0-9)]

Jan H. schrieb:
> Ich will den alten String benutzen. Möchte ihn aber nicht überschreiben.
>
> Die Zeichen sollen gelöscht werden die unerwünscht sind

Das widerspricht sich. Wenn du Zeichen im String löschst, dann 
überschreibst du ihn doch?

@Frank M. & Co.

Helfersyndrom? Das ist ein wirklich triviales Problem. Wenn er das nicht 
selber hinbekommt, dann bekommt er nie irgendwas hin.

[Emma W. (Gast)]

Axel S. schrieb:
> Das widerspricht sich. Wenn du Zeichen im String löschst, dann
> überschreibst du ihn doch?

Einen String einlesen und einen anderen (geänderten) zurückgeben?

[Nils P. (torus)]

Man muss das auch in C nicht zu Fuß machen:

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

void removeChars (char * input, const char *unwanted, char * output)
{
  char * substring = strtok(input, unwanted);

  *output = 0;

  while(substring != NULL) {
    strcat (output, substring);
    substring = strtok(NULL, unwanted);
  }
}


int main ()
{
  char output[100];
  char input[100];

  strcpy (input, "Gutxxen Axxxbend"); 

  removeChars (input, "x", output);
  puts (output);
  
  return 0;
}

Die Funktion erledigt auch gleich das entfernen mehrerer Zeichen. Kannst 
also xy und z in einem Rutsch aus dem String tilgen.

[Jan H. (janiiix3)]

Nils P. schrieb:
> void removeChars (char * input, const char *unwanted, char * output)
> {
>   char * substring = strtok(input, unwanted);
>
>   *output = 0;
>
>   while(substring != NULL) {
>     strcat (output, substring);
>     substring = strtok(NULL, unwanted);
>   }
> }

Die Funktion ist auch gut. Funktioniert einwandfrei.
Habe mich wahrscheinlich ein wenig undeutlich ausgedrückt.

Den String, den Ich absuchen möchte, soll bearbetiet werden. Das heißt 
die Zeichen die dort in dem String vorkommen, die gesucht werden sollen 
daraus entfernt werden.

Die Funktion von Frank M. erfüllt genau diesen Zweck. Ich werde mir 
diese jetzt mal genauer anschauen, damit Ich es verstehe. Vielen Dank 
für die Hilfe.

[Jobst Q. (joquis)]

Jan H. schrieb:
> Ich will den alten String benutzen. Möchte ihn aber nicht überschreiben.

Ein String braucht einen Puffer, also ein Stück Speicher, und einen 
Pointer.

Wenn du den alten String erhalten willst, musst du ihn in einen neuen 
Puffer kopieren. Wenn du den alten Puffer für den neuen String benutzen 
willst, geht das nicht ohne ihn zu überschreiben.


Hier eine Funktion zum kopieren ohne die Zeichen im String without:

char * stpcpywithout(char *t,const char *s,const char * without){

while (*s){
  if (strchr(without,*s)==NULL)*t++=*s;
  s++;
  }
*t=0;
return t;
}

Zurückgegeben wird ein Zeiger auf die Null am Stringende, er kann 
benutzt werden für das Anhängen von weiteren Strings oder Zeichen.

Du kannst die Kopierfunktion auch mit demselben Puffer verwenden, da der 
Lesezeiger s entweder identisch mit dem Schreibzeiger t ist oder ihm 
vorauseilt:

stpcpywithout( str, str,"x");

[Sebastian S. (amateur)]

Das ist nur auf den ersten Blick eine einfache Sache.

Wird aus: "Gutxxen Axxxbend"
"xx" und "xxx" entfernt, so soll trotzdem NICHT aus:
"Text" -> "Tet" werden.

Auch ist "Axbend" nicht besonders schön, auch wenn vorher "Axxxxbend"
da stand.

Zugegeben, "xx" ist in der deutschen Sprache wohl nicht allzu häufig, 
aber einfach über die Anzahl an Zeichen zu filtern, wird auch in die 
Hose gehen.

Ob das überhaupt - ohne Wörterbuch - machbar ist, weiß ich nicht. Aber 
allzu viel Info hat der TO ja auch nicht rübergebracht.

[Frank M. (ukw) (Moderator)]

Sebastian S. schrieb:
> Wird aus: "Gutxxen Axxxbend"
> "xx" und "xxx" entfernt, so soll trotzdem NICHT aus:
> "Text" -> "Tet" werden.

Ich nehme doch stark an, dass der TO das 'x' nur als ein exemplarisches 
Beispiel genommen hat, welches mit der tatsächlichen Aufgabe in der 
Realität gar nichts zu tun hat. Von daher sind Deine Folgerungen reine 
Spekulation.

[Schwarzseher (Gast)]

Nils P. schrieb:
> void removeChars (char * input, const char *unwanted, char * output)
> {
>   char * substring = strtok(input, unwanted);
>
>   *output = 0;
>
>   while(substring != NULL) {
>     strcat (output, substring);
>     substring = strtok(NULL, unwanted);
>   }
> }

Diese Funktion ist ohne Not O(n²) statt O(n).

Ist bei kurzen Texten sicher egal, und mag elegant zu tippen sein, aber 
grade bei so Anfänger-Fragen sollte man dazuschreiben, dass diese 
Funktion um Welten schlechter ist als die anderen Vorschläge.

Sonst passiert sowas:

Jan H. schrieb:
> Die Funktion ist auch gut.

Nein. Sie ist eine ganz Kategorie schlechter als die anderen.

[Sebastian S. (amateur)]

@Frank
>Ich nehme doch stark an, dass der TO das 'x' nur als ein exemplarisches
>Beispiel genommen hat, welches mit der tatsächlichen Aufgabe in der
>Realität gar nichts zu tun hat. Von daher sind Deine Folgerungen reine
>Spekulation.

Dann erst recht!
So kommen die Buchstaben "s" oder "f" bis zu 3-mal in einem Wort vor, 
ohne das der Herr Duden darüber meckert.

Aber worauf ich hinaus will ist: Es ist, ohne den gesamten Text im Auge 
zu behalten gefährlich, irgend welche Buchstabenkombinationen - ohne 
Quittung - zu ersetzen.

[Jan H. (janiiix3)]

Leider kann Ich hier nicht so viele "Zitatzeilen" einfügen.

Ich spreche das Beispiel von Frank M. (remove_2) an...

Jetzt muss Ich doch eine Frage los werden.. Was genau macht der Zeiger 
"*p" wenn er nicht zurück gegeben wird? Und wieso wird "*str" richtig 
zurückgegeben wenn dieser gar nicht bearbeitet wird?!

[Axel S. (a-za-z0-9)]

Wenn alle dürfen, dann ich auch. Die Funktion kopiert den String auf 
sich selbst und überspringt dabei alle Vorkommen des unerwünschten 
Zeichens. Da der Zielstring nicht länger sein kann als das Original, 
geht das immer.

Ich habe versucht, es sowohl kompakt als auch lesbar zu formulieren.

void remove_inplace(char *str, char unwanted)
{
  char *dst= str;
  char c;
  while ((c= *str++))
    if (c != unwanted)
      *dst++= c;

  *dst= 0;
}

so könnte man das verwenden:

int main(void)
{
  char s[]= "Halxxlo Wexlt!";
  printf("vorher:  '%s'\n", s);
  remove_inplace(s, 'x');
  printf("nachher: '%s'\n", s);
}

[Frank M. (ukw) (Moderator)]

Jan H. schrieb:
> Jetzt muss Ich doch eine Frage los werden.. Was genau macht der Zeiger
> "*p" wenn er nicht zurück gegeben wird? Und wieso wird "*str" richtig
> zurückgegeben wenn dieser gar nicht bearbeitet wird?!

Du meinst:

            for (p = str; *p; p++)
            {
                *p = *(p + 1);
            }

Der Pointer p läuft von der Stelle los, an der str gerade steht und 
"zieht" die Zeichen, die rechts davon stehen, um eine Stelle nach links. 
Die for-Schleife wird beendet, wenn der String zu Ende ist.

Beispiel: "abcxdef" im RAM untereinander geschrieben:

   a
   b
   c
   x  <--- da steht im Moment str und damit auch p wgen for (p = str;...)
   d
   e
   f
   \0 Hier ist der String zu Ende

Wegen *p = *(p + 1) wird nun das d an die Stelle von x kopiert, e an die 
alte Stelle von d, f an die alte Stelle von e. Als letztes wird noch der 
String-Terminator \0 nach links kopiert. Nach Durchlauf der for-Schleife 
steht dann im RAM:

   a
   b
   c
   d  <--- da steht immer noch str
   e
   f
   \0 Nun ist der String-Terminator eine Stelle weiter links
   \0 Der alte String-Terminator, hier steht jetzt p

Damit wurde das x eliminiert und der Teilstring "def" inkl. Terminator 
ist um eine Stelle nach links gewandert.

Deine Frage zeigt, dass Du noch waschechter Anfänger bist. Ich gebe Dir 
nochmal den Tipp, ein C-Buch systematisch durchzuarbeiten. Man kann 
keine Programmiersprache in einem Forum lernen. Außerdem sind Pointer 
bei einem C-Kurs erst dran, wenn man die Basis bereits gelernt hat.

[A. S. (Gast)]

Nur mal die Auflösung aus 
Beitrag "Re: Bestimmte Zeichen aus String entfernen? GCC":

char * strcpy(char *s1, const char *s2)
{
void *s = s1;

  while(*s2) *s1++ = *s2++;
  *s1 = (char)0;
  return s;
}

Anpassungen:
1) es braucht keinen Rückgabewert
2) es braucht nur einen Pointer (s1 = s2)
3) es braucht ein zu entfernendes Zeichen (int c)
4) umdrehen auf do while, damit keine Sonderbehandlung für abschließende 
0
5) Sicherstellen, dass c==0 nichts schlimmes macht (was immer auch dann 
passieren sollte)

void strcpy_masked(char *s, int c)
{
const char *s_read = s;

    do if(*s_read!=c || c==0) *s++ = *s_read; while(*s_read++);
}

und mit ein wenig mehr klammern und ein flg, das nicht unnötig kopiert 
wird (wobei diese Version meist nicht!! schneller ist):

void strcpy_masked(char *s, int c)
{
const char *s_read = s;
int copy=0;

    do
    {
        if(*s_read==c && c!=0) 
        {
            copy = 1;
        }
        else if(copy)
        {
            *s++ = *s_read; 
        }
        else
        {
             s++;
        }
    }while(*s_read++);
}