# Groß in Kleinbuchstaben umwandeln  --- Windows



## MaTriXxx (3. März 2011)

Es geht um folgende Aufgabenstellung:


6 Funktionen programmieren in welchen Klein in Großbuchstaben und umgekehrt umgewandelt werden sollen. Habe bei diesem Code mit Ü begonnen, allerdings scheint er dies nicht umwandeln zu wollen, wisst ihr eine Lösung auf dieses heikle Problem****



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

int islower_dt(int ch);
int isupper_dt(int ch);
int isalpha_dt(int ch);
int tolower_dt(int ch);
int toupper_dt(int ch);
int convert_dt(int ch);

int main(){
    char ch;


    while(ch!=EOF){
    ch=getchar();
    printf("%c", convert_dt(ch));
    }
    return 0;
}

int isalpha_dt(int ch){
    if((ch>='a'&& ch<='z') || (ch>='A' && ch<='Z')){
        return 1;
    } else {
        return 0;
    }

}

int islower_dt(int ch){
    if(isalpha_dt(ch)==1){
        if(ch>='a' && ch<='z'){
            return 1;
        }
    } else {
        return 0;
    }
    return 0;
}

int isupper_dt(int ch){
    if(isalpha_dt(ch)==1){
        if(ch>='A' && ch<='Z'){
            return 1;
        }
    } else {
        return 0;
    }
    return 0;
}

int tolower_dt(int ch){
    if(ch==154) {
    ch-=25;
    return ch;
    }
    else {
    ch+=32;
    }
    return ch;
}

int toupper_dt(int ch){
    if(ch==129) {
    ch+=25;
    } else {
        ch-=32;
      }
    return ch;
}

int convert_dt(int ch){
    if(islower_dt(ch)==1){
        ch = toupper_dt(ch);
    } else if(isupper_dt(ch)==1) {
        ch = tolower_dt(ch);
    }
    return ch;
}
```


----------



## vfl_freak (3. März 2011)

Moin,

also zur ASCII2ANSI-Umwandlung (und umgekehrt) nutze ich folgende Hilfsfunktionen :

```
/**
  * Wandelt einen Ascii-Wert in einen Ansi-Wert
  * @param ascii Der Ascii-Wert
  * @return Der Ansi-Wert
  */
 public static byte ascii2ansi(byte ascii)
 {
   switch (ascii) 
   {
     case (byte) (132):
       return (byte) (228); // ä
     case (byte) (148):
       return (byte) (246); // ö
     case (byte) (129):
       return (byte) (252); // ü
     case (byte) (142):
       return (byte) (196); // Ä
     case (byte) (153):
       return (byte) (214); // Ö
     case (byte) (154):
       return (byte) (220); // Ü
     case (byte) (225):
       return (byte) (223); // ß
     default:
       return ascii;
   }
 }


 /**
  * Wandelt einen Ansi-Wert in einen Ascii-Wert
  * @param ansi Der Ansi-Wert
  * @return Der Ascii-Wert
  */
 public static char ansi2ascii(char ansi) 
{
   switch (ansi) 
   {
     case (char) (228):
       return (char) (132); // ä
     case (char) (246):
       return (char) (148); // ö
     case (char) (252):
       return (char) (129); // ü
     case (char) (196):
       return (char) (142); // Ä
     case (char) (214):
       return (char) (153); // Ö
     case (char) (220):
       return (char) (154); // Ü
     case (char) (223):
       return (char) (225); // ß
     default:
       return ansi;
   }
 }


 /**
  * Wandelt einen Ascii-Wert in einen Ansi-Wert
  * @param ascii Der Ascii-Wert
  * @return Der Ansi-Wert
  */
 public static char ascii2ansi(char ascii)
 {
   switch (ascii) 
   {
     case (char) (132):
       return (char) (228); // ä
     case (char) (148):
       return (char) (246); // ö
     case (char) (129):
       return (char) (252); // ü
     case (char) (142):
       return (char) (196); // Ä
     case (char) (153):
       return (char) (214); // Ö
     case (char) (154):
       return (char) (220); // Ü
     case (char) (225):
       return (char) (223); // ß
     default:
       return ascii;
   }
 }
```

Gruß
Klaus

EDIT: Du musst dran denken, dass die Umlaute NICHT zwischen a-z resp. A-Z liegen !!


----------



## deepthroat (3. März 2011)

Hi.





MaTriXxx hat gesagt.:


> Es geht um folgende Aufgabenstellung:
> 
> 
> 6 Funktionen programmieren in welchen Klein in Großbuchstaben und umgekehrt umgewandelt werden sollen.


Welche Sprache? Welcher Zeichenkodierung? Sind Umlaute denn explizit gefordert oder kannst du dich auf ASCII beschränken?


MaTriXxx hat gesagt.:


> ```
> int main(){
> char ch;
> 
> ...


Diese Anweisungen haben undefiniertes Verhalten zur Folge, da die Variable ch nicht initialisiert ist. Außerdem liegt EOF nicht im Definitionsbereich von char.

Besser so:
	
	
	



```
int ch;

while ((ch = getchar()) != EOF) {
...
}
```
Gruß


----------



## MaTriXxx (3. März 2011)

Guten Tag und danke für die schnelle Rückmeldung.

Ich kann mich leider nur auf ASCII's beschränken. Sprache ist C. Umlaute sind unbedingt erforderlich.


----------



## MaTriXxx (3. März 2011)

Die Differenz der beiden Ü-Varianten sind ja immer ausgeglichen worden, dennoch gibt er es nicht richtig aus....


----------



## deepthroat (3. März 2011)

MaTriXxx hat gesagt.:


> Guten Tag und danke für die schnelle Rückmeldung.
> 
> Ich kann mich leider nur auf ASCII's beschränken.


Was meinst du mit ASCII's? Anscheinend verwendest du CP850?



MaTriXxx hat gesagt.:


> Umlaute sind unbedingt erforderlich.


Schreibe dir am besten einen Testtreiber für alle deine Funktionen. Du solltest zuerst mal überprüfen, das isalpha_dt() für 'Ü' auch "1" zurückgibt usw.

Gruß


----------



## MaTriXxx (3. März 2011)

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

int islower_dt(int ch);
int isupper_dt(int ch);
int isalpha_dt(int ch);
int tolower_dt(int ch);
int toupper_dt(int ch);
int convert_dt(int ch);

int main(){
    int ch;


    while(ch!=EOF){
    ch=getchar();
    printf("%c", convert_dt(ch));
    }
    return 0;
}

int isalpha_dt(int ch){
    if((ch>='a'&& ch<='z') || (ch>='A' && ch<='Z') || (ch=='ü' || ch=='Ü')){
        return 1;
    } else {
        return 0;
    }

}

int islower_dt(int ch){
    if(isalpha_dt(ch)==1){
        if(ch>='a' && ch<='z'){
            return 1;
        }
    } else {
        return 0;
    }
    return 0;
}

int isupper_dt(int ch){
    if(isalpha_dt(ch)==1){
        if(ch>='A' && ch<='Z'){
            return 1;
        }
    } else {
        return 0;
    }
    return 0;
}

int tolower_dt(int ch){
    if(ch==154) {
    ch-=25;
    return ch;
    }
    else {
    ch+=32;
    }
    return ch;

}


int toupper_dt(int ch){
    if(ch==129) {
    ch+=25;
    } else {
        ch-=32;
      }
    return ch;
}

int convert_dt(int ch){
    if(islower_dt(ch)==1){
        ch = toupper_dt(ch);
    } else if(isupper_dt(ch)==1) {
        ch = tolower_dt(ch);
    }
    return ch;
}
```

Nun habe ich den Code etwas angepasst, um den Wert 1 auch für die Ü's zurückzuliefern und zu übergeben, aber sie werde dennoch nicht umgewandelt. Int wurde umgebessert, "kleiner" Schönheitsfehler.


----------



## sheel (3. März 2011)

Hi

hast du den Code aus irgendeinem grafischen Programm herauskopiert? Ich vermute es einmal.

Dann wirst du wahrscheinlich (wie von deepthroat schon erwähnt) an den verschiedenen Zeichensätzen/Codepages scheitern: Ein Ü in Visual Studio hat einen anderen Zahlenwert als ein Ü in der Konsole.

Schreib doch einfach einmal ein
printf("%c",'Ü');
Wird da beim Starten wirklich ein Ü ausgegeben?

Gruß


----------



## MaTriXxx (3. März 2011)

Thema kann wieder gelöscht werden, da ich es nun anders mache, denn ich habe nicht genügend Zeit stundenlang zu schreiben


----------



## sheel (3. März 2011)

Dann eben nicht...das einfache printf da oben hätte aber nicht mal 10 Sekunden gedauert.

Wenn du nicht mitmachst, können wir dir auch nicht helfen.

Gruß


----------



## MaTriXxx (3. März 2011)

Habe ich doch, nur sind keine wirklich verständlichen Antworten gekommen..


----------



## sheel (3. März 2011)

Dann eben einfacher erklärt:
Alle Buchstaben, die du anzeigen kannst, sind durchnummeriert.
Zum Beispiel ein kleines a ist 97, b ist 98, ein großes A ist 65, B 66, die Ziffer 0 ist 48, 1 ist 49, Leerzeichen 32 usw...

Wenn du zwei Buchstaben vergleichen willst, wird in Wirklichkeit nur die Nummer verglichen.

Das Problem an der Sache ist: Grafische Programme in Windows (also auch Visual Studio, oder wo auch immer du deinen Quelltext schreibst) haben ein anderes Nummernsystem als die Konsole in Windows.

Die englischen Buchstaben (also A-Z ohne ÄÖÜß) haben in beiden Nummerierungen die selben Nummern.
Die deutschen Umlaute aber nicht.

Wenn du jetzt also ein ü in dein printf im Visual Studio (etc) schreibst und kompilierst, wird die ü-Nummer von der Grafikseite verwendet.
Wenn das aber in der Konsole ausgegeben wird kommt das Zeichen raus, das bei der Konsole an dieser Nummer steht. Leider kein ü.
Dasselbe gilt, wenn du ein ü in der Konsole eingibst (getchar, scanf...) und mit einem reinkompilierten Grafik-ü vergleichst.
Verschiedene Nummern, nicht gleich.

Ist es so verständlicher?

Gruß


----------



## deepthroat (4. März 2011)

MaTriXxx hat gesagt.:


> Nun habe ich den Code etwas angepasst, um den Wert 1 auch für die Ü's zurückzuliefern und zu übergeben, aber sie werde dennoch nicht umgewandelt.


Hast du das überprüft, ob das auch wirklich der Fall ist? Schreib dir einen Testtreiber, teste deinen Code!

Die anderen Funktionen solltest du natürlich auch testen, islower_dt sollte 1 für 'ü' zurückgeben!


MaTriXxx hat gesagt.:


> Int wurde umgebessert, "kleiner" Schönheitsfehler.


Du verwendest allerdings immer noch eine nicht initialisierte Variable und du überprüfst auch nicht den Rückgabewert von getchar.

Gruß


----------

