Leerzeichen aus einem String löschen?

[Tobias Mehrl (Gast)]

Hi Leute!

Ich hab folgendes Problem. Ich soll aus einem String (ich benutze dafür 
Sätze) die evtl. darinstehenden Leerzeichen löschen. Dass man direkt 
eine Stelle eines Arrays nicht löschen kann ist mir klar. Jetzt hab ich 
es so versucht:

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<iostream>
using namespace std;


int main()
{
 char satzpalindrom[30], satzohneleerzeichen[30], dummy[30], dummy2[30];
 int sp_size, i, j, k;

 printf("Bitte Satz eingeben: ");
 cin.getline(satzpalindrom, 30);


 sp_size = strlen(satzpalindrom);


j = 0;
for(i=0; i<sp_size; i=i+1)
{
  if(satzpalindrom[i] == ' ')
  {
    dummy2[j] = i;
    j = j + 1;
  }
  else
  {

  }
} 
 
system("pause");
return 0;
}

Das Programm liest mir eine Zeichenkette ein und schreibt mir in das 
array "Dummy2" die Stellen des Strings als Zahl rein, in denen ein 
Leerzeichen ist. Jetzt weiß ich zumindestens schon mal wie viel 
Leerzeichen drin sind und an welchen Stellen. Nur wie bekomme ich jetzt 
mit diesem gewonnenen Wissen die Leerzeichen aus meiner Zeichenkette 
"satzpalindrom"?

Ich kann bisher nur Schleifen, Funktionen, Felder und Zeichenketten. Die 
Funktion isalpha dürfen wir benutzen. Pointer oder ähnliches haben wir 
noch nicht durchgenommen...

Könnt ihr mir helfen?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:

> Könnt ihr mir helfen?

Du gehst das falsch an.

Stell dir einfach vor, du müsstest den String umkopieren. Und du 
kopierst einfach nur die Buchstaben um, die keine Leerzeichen sind.

Ooops. Fertig. Das Ergebnis ist dein Eingabstring ohne Leerzeichen.

Das umkopieren kann man auf 2 Arten machen: Entweder in ein neues 
Character Array, oder aber eleganter in dasselbe Character Array. Aber 
da du in deinem Programm sowieso schon dafür ein extra Array vorgesehen 
hast, ist die erste Version fein.

vergiss nicht auf Tabulatoren und Satzzeichen. Die werden m.W. bei 
Palindromen ebenfalls ignoriert :-)

[Floh (Gast)]

Tobias Mehrl schrieb:
> Könnt ihr mir helfen?

Ich würds so probieren (ohne Gewähr)

char mitleer[30];
char ohneleer[30];

char *quelle = mitleer;
char *ziel = ohneleer;

for(  ;*quelle != '\0'; *quelle++)  //solange mitleer nicht zu ende
{
  if(*quelle != ' ')
   *ziel++ = *quelle;
}
*ziel = '\0';  //abschließendes Nullbyte

:-)

[Floh (Gast)]

Sorry les erst jetzt das du keine Pointer hast.
allerdings lässt sich in diesem Fall der Pointer auch durch Zugriffe auf 
das Array ersetzen.
:-)

[Klaus W. (mfgkw)]

> Ich würds so probieren (ohne Gewähr)

Die letzte Zuweisung kann man sich schenken, wenn man eine
do...while-Schleife nimmt.
Die passt hier besser.

[Karl H. (kbuchegg)]

Floh schrieb:
> Sorry les erst jetzt das du keine Pointer hast.
> allerdings lässt sich in diesem Fall der Pointer auch durch Zugriffe auf
> das Array ersetzen.
> :-)

Macht nichts.
er soll's ja selber lernen. Und so schwer ist das nicht. Er hatte nur zu 
kompliziert gedacht.

(PS: Strings geht man besser mit einer while Schleife durch
    while( *quelle != '\0' ) {
  oder do .... while( *quelle )
 meistens hat man dann weniger Sonderfälle.)

[Tobias Mehrl (Gast)]

Diese umkopieren hört sich gut an.

Ich hab heute auch noch die Funktion strcpy aus string.h kennengelernt. 
Muss ich damit arbeiten?

[Klaus W. (mfgkw)]

nein, weil die würde die Leerzeichen mitkopieren.
Du musst strcpy() nachbauen, mit der kleinen Änderung.

Ein sinnvolle Vorübung wäre m.E. deshalb, strcpy() nachzubauen
und dann anschließend zu ändern - wobei du in diesem Fall
in die gleiche Stelle kopieren kannst, von der du auch liest.

[Tobias Mehrl (Gast)]

strcpy nachbauen? Ich würde es so machen:

#include<stdio.h>
#include<string.h>
#include<iostream.h>
using namespace std;


int main()
{
 char satzpalindrom[30], text[30];
 int i, len;

 printf("Bitte Satz eingeben: ");
 cin.getline(satzpalindrom, 30);


 len = strlen(satzpalindrom);
 
 
 for(i=0; i<=len; i=i+1)
 {
  text[i] = satzpalindrom[i];
 }
          
 printf("%s", text);
 
 

return 0;
}

Probleme hab ich mit der kleinen Änderung... Ich will ja echte Zeichen 
umkopieren. Irgendwie raff ich das an der Stelle nicht...

Könnt ihr mir vielleicht schrittweise helfen wie ich nun mein Problem in 
meine nachgebaut strcpy implementiere?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> strcpy nachbauen? Ich würde es so machen:

Sieht nicht schlecht aus.

> Probleme hab ich mit der kleinen Änderung... Ich will ja echte Zeichen
> umkopieren. Irgendwie raff ich das an der Stelle nicht...

Warum nicht?

satzpalindrom[i] ist das Zeichen an der Stelle i im String.
Es wird nur dann umkopiert, wenn es kein Leerzeichen ist.

Aber: Du kannst es nicht an die Stelle i in Text kopieren. Den das Ziel 
kann ja eine ganz andere Indexnummer haben. Du wirst daher noch eine 
2.te Variable brauchen, nennen wir sie j, in der steht wo denn in Text 
das Zeichen satzpalindrom[i] abgelegt werden soll, wenn es denn kopiert 
werden müsste.

Einfach mal auf dem Papier probieren.
Der Satz sei "He du"

  satzpalindrom
  +---+---+---+---+---+---+
  | H | e |   | d | u | \0|
  +---+---+---+---+---+---+

  text
  +---+---+---+---+---+---+
  |   |   |   |   |   |   |
  +---+---+---+---+---+---+

und los gehts.
erstes Zeichen  satzpalindrom[0]: H
ist kein Leerzeichen, wird also umkopiert. Wo genau hin? An text[0]

  satzpalindrom
  +---+---+---+---+---+---+
  | H | e |   | d | u | \0|
  +---+---+---+---+---+---+

  text
  +---+---+---+---+---+---+
  | H |   |   |   |   |   |
  +---+---+---+---+---+---+


nächstes Zeichen, satzpalindrom[1]: e
wieder: kein Leerzeichen, wird also umkopiert.
Wohin? nach text[1]

  satzpalindrom
  +---+---+---+---+---+---+
  | H | e |   | d | u | \0|
  +---+---+---+---+---+---+

  text
  +---+---+---+---+---+---+
  | H | e |   |   |   |   |
  +---+---+---+---+---+---+

Nächstes Zeichen, satzpalindrom[2]:
Ist ein Leerzeichen, nichts weiter passiert

Nächstes Zeichen, satzpalindrom[3]:  d
kein Leerzeichen, wird umkopiert
Wohin? nach text[2], denn zuletzt wurde ja text[1] beschrieben

  satzpalindrom
  +---+---+---+---+---+---+
  | H | e |   | d | u | \0|
  +---+---+---+---+---+---+

  text
  +---+---+---+---+---+---+
  | H | e | d |   |   |   |
  +---+---+---+---+---+---+

Nächstes Zeichen, satzpalindrom[4]:  u
kein Leerzeichen, wird umkopiert
Wohin, nach text[3]

  satzpalindrom
  +---+---+---+---+---+---+
  | H | e |   | d | u | \0|
  +---+---+---+---+---+---+

  text
  +---+---+---+---+---+---+
  | H | e | d | u |   |   |
  +---+---+---+---+---+---+

Und dann bleibt noch das abschliessende \0, das ja ebenfalls nicht als 
Leerezeichen gilt und daher auch umkopiert wird

  satzpalindrom
  +---+---+---+---+---+---+
  | H | e |   | d | u | \0|
  +---+---+---+---+---+---+

  text
  +---+---+---+---+---+---+
  | H | e | d | u | \0|   |
  +---+---+---+---+---+---+


Das Eregbnis sieht richtig aus. Alle Leerzeichen sind verschwunden.

[Klaus W. (mfgkw)]

Ich würde es nicht so machen, weil der Aufruf von strlen()
überflüssig ist und nur Zeit kostet.

PS: machen kann man es natürlich auch so, ich will ja nicht
zuviel meckern.
Erstmal muß es korrekt funktionieren.

[Tobias Mehrl (Gast)]

Nehmen wir mal als Beispiel den satz: Hallo du da! (ist zwar kein 
Palindrom aber er hat Leerzeich und um die gehts ja.)

So, nun kopiere ich 'H' an meine 0te Stelle in meinem neuen Array; 
genauso verfahre ich nun bis ich zum 'o' komme. Nun kommt aber an der 5. 
Stellen ein Leerzeichen. Woher weiß nun aber die for-Schleife (mit der 
ich ja umkopiere) das hier nun ein Leerezeichen kommt, welches sie nicht 
kopieren darf?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Nehmen wir mal als Beispiel den satz: Hallo du da! (ist zwar kein
> Palindrom aber er hat Leerzeich und um die gehts ja.)
>
> So, nun kopiere ich 'H' an meine 0te Stelle in meinem neuen Array;
> genauso verfahre ich nun bis ich zum 'o' komme. Nun kommt aber an der 5.
> Stellen ein Leerzeichen. Woher weiß nun aber die for-Schleife (mit der
> ich ja umkopiere)

Die for-Schleife weiss das auch nicht. DIe interessiert das auch nicht 
weiter. Aber du kannst ja innerhalb des for noch ein if machen. Niemand 
hindert dich daran. Und du musst den Buchstaben, wenn du ihn umkopierst 
auch nicht nach text[i] kopieren

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Ich würde es nicht so machen, weil der Aufruf von strlen()
> überflüssig ist und nur Zeit kostet.

Bitte bedenken: Er ist Anfänger!
Keine Pointer, einfacher naheliegender Code

[Tobias Mehrl (Gast)]

Und mit genau dieser if-Abfrage prüfe ich auf das Leerzeichen, stimmts?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Und mit genau dieser if-Abfrage prüfe ich auf das Leerzeichen, stimmts?

Genau.

Aber scroll noch mal hoch.
Da fehlt noch eine Zutat. Ich hab weiter oben ein längeren Abschnitt 
gemacht, der dich auf die wichtige Idee bringen soll.

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Bitte bedenken: Er ist Anfänger!
> Keine Pointer, einfacher naheliegender Code

Es geht mit Index auch ohne strlen, aber ich habe ja auch
schon eingesehen, daß es nicht so wichtig ist :-)

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Karl heinz Buchegger schrieb:
>> Bitte bedenken: Er ist Anfänger!
>> Keine Pointer, einfacher naheliegender Code
>
> Es geht mit Index auch ohne strlen, aber ich habe ja auch
> schon eingesehen, daß es nicht so wichtig ist :-)

:-)
(Bin neugierig, wann der Groschen bei ihm fällt)

[Tobias Mehrl (Gast)]

So Leute, ich glaub ich hab fertig:

hier mein code:

#include<stdio.h>
#include<string.h>
#include<iostream.h>
using namespace std;


int main()
{
 char satzpalindrom[30], text[30];
 int i, j, len;

 printf("Bitte Satz eingeben: ");
 cin.getline(satzpalindrom, 30);


 len = strlen(satzpalindrom);
 
 j = 0;
 for(i=0; i<=len; i=i+1)
 {
  if(satzpalindrom[i] != ' ')
  {
   text[j] = satzpalindrom[i];
   j = j + 1;
  }
  else
  {
   
  }
 }
          
 printf("%s", text);
 
 
system("pause");
return 0;
}

Könnt ihr mal gucken ob das so jetzt passt? mein compiler meckert nicht 
und auch das ergebnis passt...

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:

> Könnt ihr mal gucken ob das so jetzt passt? mein compiler meckert nicht
> und auch das ergebnis passt...

Ist richtig.

Habt ihr schon while-Schleifen gemacht?

[Klaus W. (mfgkw)]

Sieht korrekt aus.

[Karl H. (kbuchegg)]

Was mir gefällt:
Du hast bereits angefangen einen Formatier-Stil zu entwickeln. Noch 
etwas zaghaft, aber das wird mit der Zeit.
Mach weiter so.


PS:
Wenn in einem else nichts steht, dann lass es besser weg. Code 
übersichtlich zu machen ist eine Sache. Aber ihn ohne Not in die Länge 
zu ziehen geht in die falsche Richtung

 for(i=0; i<=len; i=i+1)
 {
  if(satzpalindrom[i] != ' ')
  {
   text[j] = satzpalindrom[i];
   j = j + 1;
  }
 }

ist genausogut, wenn nicht sogar besser weil nicht so in die Länge 
gezogen. Je näher die abschliessende } zur jeweils öffnenden { steht, 
umso leichter ist es den Überblick zu behalten, wie die einzelnen Teile 
ineinander geschachtelt sind.

[Karl H. (kbuchegg)]

@Klaus:
Ich hab getline schon lang nicht mehr benutzt. Liefert das eigentlich 
den \n mit oder nicht? (Das könnte einer der nächsten Stolpersteine 
werden, nachdem er den String umgedreht hat)

[Tobias Mehrl (Gast)]

Ich verstehe nicht, warum ich hier eine 149 len2 stehen hab bei einer 
Zeichenkette von 31...

Hier mein Code:

len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<=len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   ohneleer[j] = satzpalindrom[i];
   j = j + 1;
  }
 }
 len2 = strlen(ohneleer);
 ohneleer[len2] = satzpalindrom[len1];    //0-Terminierung an die richtige Stelle ins Array

[Tobias Mehrl (Gast)]

Sorry, wenn ich das etwas unverständlich geschrieben hab.

Ich gebe z.B. eine Zeichenkette von 7 Zeichen ein. len1 passt noch das 
gibt 7 aus. len2 ist aber dann unverständlicherweise 115... Was is'n da 
jetzt falsch?

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> @Klaus:
> Ich hab getline schon lang nicht mehr benutzt. Liefert das eigentlich
> den \n mit oder nicht? (Das könnte einer der nächsten Stolpersteine
> werden, nachdem er den String umgedreht hat)

nein, tut es glaube ich nicht

[Klaus W. (mfgkw)]

Tobias Mehrl schrieb:
> Ich gebe z.B. eine Zeichenkette von 7 Zeichen ein. len1 passt noch das
> gibt 7 aus. len2 ist aber dann unverständlicherweise 115... Was is'n da
> jetzt falsch?

Durch das isalpha wird die abschließende 0 nicht mitkopiert,
also ist der erzeugte String nicht terminiert.
Ein strlen() darauf zählt also bis zur ersten zufällig im Speicher
stehenden 0.

[mh (Gast)]

Die Information, die das 2. strlen liefert hast du ja auch so schon.

[Tobias Mehrl (Gast)]

Wo steht die Information die ich anscheinend schon habe und mir mein 
zweite strlen ersetzt?

[Karl H. (kbuchegg)]

> Durch das isalpha wird die abschließende 0 nicht mitkopiert,
> also ist der erzeugte String nicht terminiert.

Genau.

Und deshalb ist das hier

 len2 = strlen(ohneleer);
 ohneleer[len2] = satzpalindrom[len1];    //0-Terminierung an die richtige Stelle ins Array

so nicht möglich.

strlen ist darauf angewiesen, dass die 0-Terminierung schon am richtigen 
Platz ist. Du musst daher deine 0-Terminierung auf einem anderen Weg an 
die richtige Stelle schreiben. Und erst dann kannst du irgendeine der 
str... Funktionen benutzen.

Du hast hier versucht, das Pferd von hinten aufzuzäumen.

[Tobias Mehrl (Gast)]

Darf ich über "ohneleer[len2] = satzpalindrom[len1];" schreiben?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Darf ich über "ohneleer[len2] = satzpalindrom[len1];" schreiben?

Nein.
Denn len2 hast du ja noch nicht.

Aber du hast eine andere Variable, die dir verrät, wieviele Zeichen du 
in ohneleer hineingegeben hast.

[Tobias Mehrl (Gast)]

Hm, dann bin ich mit meinem Latein am Ende... Wie bring ich dann im 
String ohneleer die 0-Terminierung in Abhängigkeit des eingegebenen 
Strings an die richtige Stelle?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Hm, dann bin ich mit meinem Latein am Ende... Wie bring ich dann im
> String ohneleer die 0-Terminierung in Abhängigkeit des eingegebenen
> Strings an die richtige Stelle?

Innerhalb der SChleife:
Wohin würde der nächste Buchstabe geschrieben werden, wenn noch einer da 
wäre?

Überleg doch mal, welche Aussage dir dein j erlaubt!

[Tobias Mehrl (Gast)]

"Aber du hast eine andere Variable, die dir verrät, wieviele Zeichen du
in ohneleer hineingegeben hast."

Soll das dann j sein?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> "Aber du hast eine andere Variable, die dir verrät, wieviele Zeichen du
> in ohneleer hineingegeben hast."
>
> Soll das dann j sein?

:-)

[Tobias Mehrl (Gast)]

So siehts aus:

 len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<=len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   ohneleer[j] = satzpalindrom[i];
   j = j + 1;
  }
 }
 ohneleer[j] = satzpalindrom[len1];    //0-Terminierung an die richtige Stelle ins Array

Geht aber auch nicht. In ohneleer steht nach wie vor keine 0

[Klaus W. (mfgkw)]

doch

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> So siehts aus:
>
>

>  len1 = strlen(satzpalindrom);
>  j = 0;              //Leerzeichen entfernen
>  for(i=0; i<=len1; i=i+1)
>  {
>   if(isalpha(satzpalindrom[i]))
>   {
>    ohneleer[j] = satzpalindrom[i];
>    j = j + 1;
>   }
>  }
>  ohneleer[j+1] = satzpalindrom[len1];    //0-Terminierung an die
> richtige Stelle ins Array

>
>
> Geht aber auch nicht. In ohneleer steht nach wie vor keine 0

Wenn du ohnehin weißt, dass du das Zeichen '\0' dort reinbugsieren 
musst, warum schreibst du es dann nicht einfach als '\0' sondern 
versuchst es dir aus satzpalindrom zu holen? Und dann dort auch noch von 
der falschen Stelle.

Wenn du dir nicht sicher bist (da ist dann noch ein Fehler), dann spiels 
auf einem Stück Papier durch

Gegeben sei der String

   +---+---+---+---+---+---+     +---+---+---+---+---+---+---+---+
   | H | e |   | d | u | \0|     |   |   |   |   |   |   |   |   |
   +---+---+---+---+---+---+     +---+---+---+---+---+---+---+---+

den du nach rechts umkopieren musst.
Welche Werte haben in jedem Schleifendurchgang i und j, was passiert 
innerhalb der Schleife


    i      j       Aktion
  -------------------------
    0      0        H umkopieren, j wird 1
   +---+---+---+---+---+---+     +---+---+---+---+---+---+---+---+
   | H | e |   | d | u | \0|     | H |   |   |   |   |   |   |   |
   +---+---+---+---+---+---+     +---+---+---+---+---+---+---+---+

    1      1


(du machst weiter)

[Klaus W. (mfgkw)]

Abgesehen davon, kann die Schleife auch getrost einmal weniger
durchlaufen werden.
Bisher hast du i<=len1, aber bei gleich len1 bist du ja an
der 0, die du wegen isalpha() sicher nicht kopierst.
i<len1 würde also auch reichen.

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Und dann dort auch noch von der falschen Stelle.

Daß es besser gleich als '\0' genommen werden könnte, ist natürlich
korrekt.
Aber wenn ich jetzt keinen Aussetzer habe, nimmt er es schon
von der richtigen Stelle (len1).

[Tobias Mehrl (Gast)]

Jetzt hab ich's so: (ich hab's auch auf dem papier durchgespielt.... da 
passts)

len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   ohneleer[j] = satzpalindrom[i];
   j = j + 1;
  }
 }
 ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins Array

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Karl heinz Buchegger schrieb:
>> Und dann dort auch noch von der falschen Stelle.
>
> Daß es besser gleich als '\0' genommen werden könnte, ist natürlich
> korrekt.
> Aber wenn ich jetzt keinen Aussetzer habe, nimmt er es schon
> von der richtigen Stelle (len1).


Nope
>  len1 = strlen(satzpalindrom);

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Tobias Mehrl schrieb:
>> So siehts aus:
>>
>>

>>  len1 = strlen(satzpalindrom);
>>  j = 0;              //Leerzeichen entfernen
>>  for(i=0; i<=len1; i=i+1)
>>  {
>>   if(isalpha(satzpalindrom[i]))
>>   {
>>    ohneleer[j] = satzpalindrom[i];
>>    j = j + 1;
>>   }
>>  }
>>  ohneleer[j+1] = satzpalindrom[len1];    //0-Terminierung an die
>> richtige Stelle ins Array

>>
>>
>> Geht aber auch nicht. In ohneleer steht nach wie vor keine 0
> ...

Wo kommt jetzt ohneleer[j+1] = satzpalindrom[len1]; her?
Eben hieß es noch richtigerweise ohneleer[j] = satzpalindrom[len1];

[Karl H. (kbuchegg)]

Karl heinz Buchegger schrieb:
> Klaus Wachtler schrieb:
>> Karl heinz Buchegger schrieb:
>>> Und dann dort auch noch von der falschen Stelle.
>>
>> Daß es besser gleich als '\0' genommen werden könnte, ist natürlich
>> korrekt.
>> Aber wenn ich jetzt keinen Aussetzer habe, nimmt er es schon
>> von der richtigen Stelle (len1).
>
>
> Nope
>>  len1 = strlen(satzpalindrom);

Arrgh.
Ja, du hast recht. War jetzt im Eifer des Gefechts.

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Nope

Doch!

Angenommen char str[] = "abc", dann hat len1=strlen(str) den Wert 3.
Und str[3] ist die abschließende 0, oder gebe ich besser mein
nicht existierendes Informatikdiplom zurück?

[Klaus W. (mfgkw)]

ok, abgehakt

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Jetzt hab ich's so: (ich hab's auch auf dem papier durchgespielt.... da
> passts)
>
>

len1 = strlen(satzpalindrom);
>  j = 0;              //Leerzeichen entfernen
>  for(i=0; i<len1; i=i+1)
>  {
>   if(isalpha(satzpalindrom[i]))
>   {
>    ohneleer[j] = satzpalindrom[i];
>    j = j + 1;
>   }
>  }
>  ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins
> Array
>

Ja, so passts.
j ist nach der Schleife gleich der Anzahl der umkopierten Buchstaben und 
damit auch gleichzeitig die Länge des Strings. Nur der String muss das 
auch noch wissen :-) Und dafür hast du jetzt korrekterweise gesorgt.
Ab jetzt steht in ohneleer wieder ein korrekter C-String mit dem man 
weiterarbeiten kann.

[Klaus W. (mfgkw)]

Tusch, und jetzt kann man es schöner machen :-)

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Tusch, und jetzt kann man es schöner machen :-)

:-)  (auflach)
Der strlen ist dir ein Dorn im Auge.
Mir auch.

Fang an. Oder präsentieren wir ihm die Alternative? Ich denk es wäre 
vertretbar, weil die Denkweise dann doch ganz anders ist.

[Tobias Mehrl (Gast)]

Leute nochmal kurz für mich:

Ich hab jetzt den Code:

len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   ohneleer[j] = satzpalindrom[i];
   j = j + 1;
  }
 }
 ohneleer[j] = '\0';

Wenn ich mir jetzt in Visual Studio 2010 die Strings ansehe, dann steht 
in ohneleer zwar keine Leerzeichen mehr drin und nur noch die buchstaben 
aber keine 0...

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Leute nochmal kurz für mich:
>
> Ich hab jetzt den Code:
>
> [c]
> len1 = strlen(satzpalindrom);
>  j = 0;              //Leerzeichen entfernen
>  for(i=0; i<len1; i=i+1)
>  {
>   if(isalpha(satzpalindrom[i]))
>   {
>    ohneleer[j] = satzpalindrom[i];
>    j = j + 1;
>   }
>  }
>  ohneleer[j] = '\0';
> [c]
>
> Wenn ich mir jetzt in Visual Studio 2010 die Strings ansehe, dann steht
> in ohneleer zwar keine Leerzeichen mehr drin und nur noch die buchstaben
> aber keine 0...

Keine Sorge. Es steht eines drinnen.
Aber auch Visual Studio weiß, dass es sich bei einem char Array um einen 
String handelt und zeigt dir den auch als String an.
Oder wo genau siehst du nach? Wenn du VS dazu zwingst, dir das Ding 
einfach nur als Array zu präsentieren, dann findet sich dort auch wieder 
das \0 Byte

[Klaus W. (mfgkw)]

Ja, aber sonst sieht es doch schon nett aus.

Eigentlich gehört das noch in eine Funktion, aber dafür braucht
man Zeiger zwecks Übergabe, und x=x+1 könnte man verkürzen, und
dann wäre da noch die Sache mit der do...while-Schleife.

Aber das ist letztlich alles Makulatur.

[Tobias Mehrl (Gast)]

Ich schaue mir die Variablen immer im lokalen Modus an... Und da, steht, 
wie ihr sehen könnt, keine 0 an der Stelle 32 im array ohneleer...

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Ja, aber sonst sieht es doch schon nett aus.
>
> Eigentlich gehört das noch in eine Funktion, aber dafür braucht
> man Zeiger zwecks Übergabe, und x=x+1 könnte man verkürzen, und
> dann wäre da noch die Sache mit der do...while-Schleife.
>
> Aber das ist letztlich alles Makulatur.

Ich denke so weit sind sie noch nicht im Unterricht. Also Funktionen und 
so.

Aber, wenn ich das richtig interpretiere ist ja die Aufgabe noch nicht 
fertig. Noch wissen wir ja nicht, ob die Eingabe ein Palindrom ist oder 
nicht.

[Tobias Mehrl (Gast)]

Hier mal noch mein vollständiger Code, bzw. ich lasse nur bis dahin 
ausführen...

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<ctype.h>
using namespace std;


int main()
{
 char satzpalindrom[100], ohneleer[100], kleinzeichen, satzpalindrom_klein_ohneleer[100], ruckwartspalindrom[100];
 int i, j, len1, len2;


 printf("Bitte Satz eingeben: ");
 cin.getline(satzpalindrom, 100);


 len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   ohneleer[j] = satzpalindrom[i];
   j = j + 1;
  }
 }
 ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins Array

[Frickler (Gast)]

Wer <iostream> und <stdio.h> in einer Programmunit zusammen verwendet, 
würde bei mir einen dicken Minuspunkt kassieren ;-)

[Klaus W. (mfgkw)]

Tobias Mehrl schrieb:
> Ich schaue mir die Variablen immer im lokalen Modus an... Und da, steht,
> wie ihr sehen könnt, keine 0 an der Stelle 32 im array ohneleer...

Wann schaust du dir den String an?
Die Zeile mit der ='\0' muß erst ausgeführt worden sein!
Dazu muß der Debugger in der darauf folgenden Zeile stehen.

Falls doch nicht: welchen Wert hat j?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Leute nochmal kurz für mich:
>
> Ich hab jetzt den Code:
>
>

> len1 = strlen(satzpalindrom);
>  j = 0;              //Leerzeichen entfernen
>  for(i=0; i<len1; i=i+1)
>  {
>   if(isalpha(satzpalindrom[i]))
>   {
>    ohneleer[j] = satzpalindrom[i];
>    j = j + 1;
>   }
>  }
>  ohneleer[j] = '\0';
>

>
> Wenn ich mir jetzt in Visual Studio 2010 die Strings ansehe, dann steht
> in ohneleer zwar keine Leerzeichen mehr drin und nur noch die buchstaben
> aber keine 0...

Wenn du dir das ansiehst, wo steht der gelbe Pfeil/Punkt vom Debugger im 
Code?
Auf der Zeile
   ohneleer[j] = '\0';
oder dahinter?

Die gelbe Markierung zeigt dir immer die Zeile, die als nächstes 
ausgeführt wird aber noch nicht abgearbeitet wurde.

[Tobias Mehrl (Gast)]

Danke, ich bin zu blöd nochml die F10 Taste zu drücken... Jetzt steht 
auch eine \0 da...

[Klaus W. (mfgkw)]

Frickler schrieb:
> Wer <iostream> und <stdio.h> in einer Programmunit zusammen verwendet,
> würde bei mir einen dicken Minuspunkt kassieren ;-)

Bei mir auch, aber erstmal nur weil es <cstdio> heißt.
Oder wenn er die beiden (alt und neu) auf dieselbe Datei anwendet,
aber das ist hier nicht der Fall :-)

[Klaus W. (mfgkw)]

Den Minuspunkt bekommt er von mir stattdessen für das using namespace 
std;

[Karl H. (kbuchegg)]

Den/die Minuspunkt(e) kriegt von mir sein Lehrer.
Und zwar aus verschiedenen Gründen. Der wichtigste davon: Er kann sich 
nicht entscheiden ob er C++ oder C unterrichten soll. Statt dessen 
veranstaltet er da einen Mischmasch.

Wenn C, dann haben die C++ Header, cin und using nichts verloren.

Wenn C++, dann std::string anstelle von C-String Verarbeitung. Die kommt 
später, viel später. In der Zwischenzeit sich an den Segnungen von 
Objekten die auf sich selbst aufpassen erfreuen und zügig im Stoff 
weiterkommen.

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Den/die Minuspunkt(e) kriegt von mir sein Lehrer.

Ja, erstmal hat er als mildernde Umstände "schlechter Umgang".

[Karl H. (kbuchegg)]

OK, Tobias

Wie gehts weiter auf dem Weg zum Palindrom?
Wie sieht dein Plan aus?

[Tobias Mehrl (Gast)]

Ich hab fertig: Mein Programm für den Vergleich von Satzpalindromen 
sieht so aus:

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<ctype.h>
using namespace std;


int main()
{
 char satzpalindrom[100], ohneleer[100], kleinzeichen, satzpalindrom_klein_ohneleer[100], ruckwartspalindrom[100];
 int i, j, len1, len2;


 printf("Bitte Satz eingeben: ");
 cin.getline(satzpalindrom, 100);


 len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   ohneleer[j] = satzpalindrom[i];
   j = j + 1;
  }
 }
 ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins Array






 len2 = strlen(ohneleer);
 j = 0;
 for(i=0; i<len2; i=i+1)      //alle Buchstaben klein schreiben
 {
  kleinzeichen = tolower(ohneleer[i]);
  satzpalindrom_klein_ohneleer[j] = kleinzeichen;
  j = j + 1;
 }
 satzpalindrom_klein_ohneleer[len2] = '\0';




 j = 0;
 for(i=(len2-1); i>=0; i=i-1)    //String umdrehen
 {
  ruckwartspalindrom[j] = satzpalindrom_klein_ohneleer[i];
  j = j + 1;
 }
 ruckwartspalindrom[len2] = '\0';



 if(strcmp(ruckwartspalindrom, satzpalindrom_klein_ohneleer) == 0)    //Vergleich der beiden Zeichenketten
 {
  printf("Ja, ist ein Palindrom!\n");
 }
 else
 {
  printf("Nein, ist KEIN Palindrom!\n");
 }



system("pause");
return 0;
}

Jetzt möchte ich noch einzelne Programmteile in Funktionen auslagern 
(das haben wir schon durchgemacht) aber ich denke, dass mach ich dann 
lieber morgen. Kann ich mich morgen dazu wieder melden?

Das iostream brauch ich doch für cin.getline, oder?

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> Ich hab fertig: Mein Programm für den Vergleich von Satzpalindromen
> sieht so aus:

Okaaay

> Jetzt möchte ich noch einzelne Programmteile in Funktionen auslagern
> (das haben wir schon durchgemacht) aber ich denke, dass mach ich dann
> lieber morgen.

Ehe du das tust, schau dein Programm noch mal durch.
Da kann man noch viel tun

> Kann ich mich morgen dazu wieder melden?

Klar

>
> Das iostream brauch ich doch für cin.getline, oder?

Schon. Aber was macht eigentlich cin in einem "C" Programm?

[Karl H. (kbuchegg)]

Karl heinz Buchegger schrieb:

>> Jetzt möchte ich noch einzelne Programmteile in Funktionen auslagern
>> (das haben wir schon durchgemacht) aber ich denke, dass mach ich dann
>> lieber morgen.
>
> Ehe du das tust, schau dein Programm noch mal durch.
> Da kann man noch viel tun

zb hier

len2 = strlen(ohneleer);
 j = 0;
 for(i=0; i<len2; i=i+1)      //alle Buchstaben klein schreiben
 {
  kleinzeichen = tolower(ohneleer[i]);
  satzpalindrom_klein_ohneleer[j] = kleinzeichen;
  j = j + 1;
 }
 satzpalindrom_klein_ohneleer[len2] = '\0';

Wozu der strlen? Du kennst doch die Länge des Strings schon aus dem 
vorhergehenden Teil.
Wozu brauchst du das j hier. j hat immer denselben Wert wie i.
Wozu die zusätzliche Variable 'kleinzeichen'

 len2 = j;    // wenns schon eine Variable len2 braucht.
              // ALternativ hätte man ja auch das j weiter oben
              // gleich len2 nennen können

 for(i=0; i<len2; i=i+1)      //alle Buchstaben klein schreiben
 {
   satzpalindrom_klein_ohneleer[j] = tolower(ohneleer[i]);
 }
 satzpalindrom_klein_ohneleer[len2] = '\0';

Man hätte allerdings das tolower auch gleich in die erste SChleife mit 
aufnehmen können:

 len1 = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<len1; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   satzpalindrom_klein_ohneleer[j] = tolower( satzpalindrom[i] );
   j = j + 1;
  }
 }
 ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins Array

dann fällt schon mal Code weg, es fallen Variablen weg, etc.

Aber es ist ok.
Zum jetzigen Zeitpunkt zählt 'funktioniert' noch ein wenig mehr.

[Karl H. (kbuchegg)]

PS:
Wegen dem vorletzten Programmteil.
SChau dir mal deinen Vorrat an Funktionen in string.h durch.
Da gibt es eine Funktion namens strrev

[Klaus W. (mfgkw)]

Nicht im Standard.

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Nicht im Standard.

Echt?
OK. Dann ist das (wieder mal) mein Fehler. Bin davon ausgegangen, dass 
das mitlerweile drinnen ist, weil ich beim schnellen Goggeln immer den 
Verweis auf string.h gefunden habe.

[Torsten K. (ago)]

Karl heinz Buchegger schrieb:
> Oder präsentieren wir ihm die Alternative? Ich denk es wäre
> vertretbar, weil die Denkweise dann doch ganz anders ist.

Tobias, bitte weglesen  :)

unsigned int i,j;
...
// 0x20 raus
i=j=0;
while(text[i] = satzpalindrom[j++])
  if (text[i] != ' ') i++;
// vergleich (i zeigt auf ende /0)
j=0;
while(j<i)
  if (text[j++] != text[--i])
    { i++; j--; break; }
// ergebnis
if (j>=i)
  printf("Ist 'n palidings");
else
  printf("Ist keins");

Ich hoffe da ist jetzt (abgesehen vom Stil) kein logischer Fehler 
drin...

[Torsten K. (ago)]

Torsten K. schrieb:
> while(text[i] = satzpalindrom[j++])

Sollte natürlich doppelt geklammert werden:
while((text[i] = satzpalindrom[j++]))

[Karl H. (kbuchegg)]

Torsten K. schrieb:

> Ich hoffe da ist jetzt (abgesehen vom Stil) kein logischer Fehler
> drin...

Ich denke es müsste stimmen. (das tolower ist geschenkt)

Ich krieg die 2.te Schleife nicht weg, die ich brauch um einen Pointer 
ans Stringende zu kriegen. Keine Chance. Mit weniger als 2 mal durch den 
String gehts nicht. Ich wollte die Blanks 'on the fly' beim Durchmarsch 
bis zur Mitte überspringen. Aber ich brauch 2 Pointer. Einen von vorne, 
einen von hinten. Aber für den von hinten muss ich durch den String 
durch.

[Klaus W. (mfgkw)]

Torsten K. schrieb:
> Tobias, bitte weglesen  :)

Guter Rat! :-)

[Tobias Mehrl (Gast)]

@kbuchegg:

"Wozu der strlen? Du kennst doch die Länge des Strings schon aus dem
vorhergehenden Teil.
Wozu brauchst du das j hier. j hat immer denselben Wert wie i.
Wozu die zusätzliche Variable 'kleinzeichen'"

Das muss aber schon so heißen, oder?

for(i=0; i<len2; i=i+1)      //alle Buchstaben klein schreiben
 {
   satzpalindrom_klein_ohneleer[j] = tolower(ohneleer[i]);
 }
 satzpalindrom_klein_ohneleer[len2] = '\0';

Wenn ich das j lasse, dann kopiere ich ab der 4. Stelle ins array

Hier mal mein verbesserter und kürzere Code:

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<ctype.h>
using namespace std;


int main()
{
 char satzpalindrom[100], satzpalindrom_klein_ohneleer[100], ruckwartspalindrom[100];
 int i, j, len, k;



 printf("Bitte Satz eingeben: ");
 cin.getline(satzpalindrom, 100);



 len = strlen(satzpalindrom);
 j = 0;              //Leerzeichen entfernen
 for(i=0; i<len; i=i+1)
 {
  if(isalpha(satzpalindrom[i]))
  {
   satzpalindrom_klein_ohneleer[j] = tolower(satzpalindrom[i]);    //alle Buchstaben klein machen
   j = j + 1;
  }
 }
 satzpalindrom_klein_ohneleer[j] = '\0';    //0-Terminierung an die richtige Stelle ins Array



 k = 0;
 for(i=(j-1); i>=0; i=i-1)    //String umdrehen
 {
  ruckwartspalindrom[k] = satzpalindrom_klein_ohneleer[i];
  k = k + 1;
 }
 ruckwartspalindrom[j] = '\0';



 if(strcmp(ruckwartspalindrom, satzpalindrom_klein_ohneleer) == 0)    //Vergleich der beiden Zeichenketten
 {
  printf("Ja, ist ein Palindrom!\n");
 }
 else
 {
  printf("Nein, ist KEIN Palindrom!\n");
 }



system("pause");
return 0;
}

[Tobias Mehrl (Gast)]

So, nun möchte ich nch mein Programm in Funktionen auslagern. Ich hab 
hier ja drei Programmteile, nämlich "Leerzeichen entfernen", "String 
umdrehen" und "Strings vergleichen". Die sollten sich doch jetzt ganz 
einfach in Funktionen auslagern lassen, oder? Ich meine, abhängig sind 
doch die 3 Funktionen doch eh nur von dem einmal ganz am anfang 
eingegebenen string satzpalindrom, richtig?

[Klaus W. (mfgkw)]

Eigentlich ja.

Um Strings an Funktionen zu übergeben, brauchst du aber Zeiger.
Ggf. willst du dich erst über die schlau machen.

[Tobias Mehrl (Gast)]

Hm, is vielleicht nicht so toll, da wir Pointer. Noch gar nicht können.

Gibt es denn keine andere Möglichkeit?

[Klaus W. (mfgkw)]

Nicht sinnvoll.
Nimm dir ein Buch, mach am WE Pointer, und du hast einen Vorsprung.

[Yalu X. (yalu) (Moderator)]

Bei der Übergabe von Strings an Funktionen siehst du von den Pointern
normalerweise gar nichts, da du die Strings wie char-Arrays behandelst,
z.B. so:

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

int ispalindrom(char s[]) {
  int i=0, j=strlen(s)-1;

  while(i < j) {
    if(!isalpha(s[i]))
      i++;
    else if(!isalpha(s[j]))
      j--;
    else if(tolower(s[i++]) != tolower(s[j--]))
      return 0;
  }
  return 1;
}

int main(void) {
  char line[100];

  printf("Bitte einen Satz eingeben:\n");
  fgets(line, sizeof line, stdin);
  if(ispalindrom(line))
    printf("Ja, ist ein Palindrom!\n");
  else
    printf("Nein, ist KEIN Palindrom!\n");
}

[Arc N. (arc)]

Yalu X. schrieb:
> Bei der Übergabe von Strings an Funktionen siehst du von den Pointern
> normalerweise gar nichts, da du die Strings wie char-Arrays behandelst,
> z.B. so:
>
>

> #include <stdio.h>
> #include <string.h>
> #include <ctype.h>
> 
> int ispalindrom(char s[]) {
>   int i=0, j=strlen(s)-1;
> 
>   while(i < j) {
>     if(!isalpha(s[i]))
>       i++;
>     else if(!isalpha(s[j]))
>       j--;
>     else if(tolower(s[i++]) != tolower(s[j--]))
>       return 0;
>   }
>   return 1;
> }
>

oder rekursiv (nicht ganz, wer will bekommt aber das strlen auch noch 
raus)

bool isPalindrome(const char* inputStr, int first, int last) {
  if ((last - first) < 1) return true; 

  if (!isalpha(inputStr[first])) isPalindrome(inputStr, first + 1, last);
  if (!isalpha(inputStr[last])) isPalindrome(inputStr, first, last - 1);
  if (tolower(inputStr[first]) != tolower(inputStr[last])) {
    return false;
  } else {
    return isPalindrome(inputStr, first + 1, last - 1);
  }
}

char text[] = "Ein Esel lese nie";
bool res = isPalindrome(text, 0, strlen(text) - 1);

[Karl H. (kbuchegg)]

Tobias Mehrl schrieb:
> @kbuchegg:
>
> "Wozu der strlen? Du kennst doch die Länge des Strings schon aus dem
> vorhergehenden Teil.
> Wozu brauchst du das j hier. j hat immer denselben Wert wie i.
> Wozu die zusätzliche Variable 'kleinzeichen'"
>
> Das muss aber schon so heißen, oder?
>
>

> for(i=0; i<len2; i=i+1)      //alle Buchstaben klein schreiben
>  {
>    satzpalindrom_klein_ohneleer[j] = tolower(ohneleer[i]);
>  }
>  satzpalindrom_klein_ohneleer[len2] = '\0';
>

>
> Wenn ich das j lasse, dann kopiere ich ab der 4. Stelle ins array

Du hast mich erwischt. War ein Copy&Paste Fehler.
Da j bei dir ja immer denselben Wert wie i hatte (an dieser Stelle) war 
natürlich gemeint

  for(i=0; i<len2; i=i+1)      //alle Buchstaben klein schreiben
  {
    satzpalindrom_klein_ohneleer[i] = tolower(ohneleer[i]);
  }
  satzpalindrom_klein_ohneleer[len2] = '\0';

Das hast du absolut richtig erkannt.