# Frage zu 2 String-Arrays

• Angenommen man hat 2 String-Arrays: char *buffer0[50] und char *buffer1[50]. Das erstere (buffer0) besteht aus Wörtern word0[] und das zweite aus Wörtern word1[]. Nun werden alle Kleinbuchstaben in buffer0 mittels toupper() zu Großbuchstaben gemacht.

Resultat: Beide String-Arrays enthalten nur noch Großbuchstaben.

Kann mir jemand erklären, warum buffer1 auch verändert wurde?

``````void toUpper(char *bufferUp[], int elements, int maxLength)
{
int i,j;
for (i=0; i<elements; i++) {
for (j=0; j<maxLength; j++) {
bufferUp[i][j] = toupper(bufferUp[i][j]);
}
}
}

int main()
{
int i;
char word0[500];
char word1[500];
char *buffer0[500];
char *buffer1[500];

strcpy(word0, "Test");
strcpy(word1, word0);
buffer0[0] = calloc(strlen(word0), sizeof(char));
buffer1[0] = calloc(strlen(word1), sizeof(char));
strcpy(buffer0[0],word0);
strcpy(buffer1[0],word1);

strcpy(word0, "Hallo");
strcpy(word1, word0);
buffer0[1] = calloc(strlen(word0), sizeof(char));
buffer1[1] = calloc(strlen(word1), sizeof(char));
strcpy(buffer0[1],word0);
strcpy(buffer1[1],word1);

strcpy(word0, "was weiss ich");
strcpy(word1, word0);
buffer0[2] = calloc(strlen(word0), sizeof(char));
buffer1[2] = calloc(strlen(word1), sizeof(char));
strcpy(buffer0[2],word0);
strcpy(buffer1[2],word1);

strcpy(word0, "Programmieren");
strcpy(word1, word0);
buffer0[3] = calloc(strlen(word0), sizeof(char));
buffer1[3] = calloc(strlen(word1), sizeof(char));
strcpy(buffer0[3],word0);
strcpy(buffer1[3],word1);

strcpy(word0, "Testprogramm");
strcpy(word1, word0);
buffer0[4] = calloc(strlen(word0), sizeof(char));
buffer1[4] = calloc(strlen(word1), sizeof(char));
strcpy(buffer0[4],word0);
strcpy(buffer1[4],word1);

strcpy(word0, "Mach was");
strcpy(word1, word0);
buffer0[5] = calloc(strlen(word0), sizeof(char));
buffer1[5] = calloc(strlen(word1), sizeof(char));
strcpy(buffer0[5],word0);
strcpy(buffer1[5],word1);

toUpper(buffer0, 6, 500);

for (i=0; i<6; i++) {
printf("%s\n",buffer0[i]);
printf("%s\n",buffer1[i]);
printf("-------------\n");
}

return 0;
}
``````

• Ich denke, du hast buffer-overflows...

Laß dir mal die Strings vor dem toUpper() ausgeben.

M.E. allozierst du zuwenig Speicher mit calloc(). Du hast das Nullterminierungszeichen vergessen: strlen(...) + 1.
(statt calloc kannst du hier auch einfach malloc verwenden)

Ansonsten einfach mal durchdebuggen...

P.S: Habe deinen grundsätzlichen Fehler entdeckt:

Deine Schleife in toUpper() ist falsch. Du denkst, deine einzelnen Strings sind immer 500 Zeichen lang, aber du hast doch jeweils nur 'char*' auf nullterminierte Strings (also wie ich vermutet habe: Speicherüberschreiber)!!!

Evtl. hast du falsch verstanden, was Zeiger und Arrays sind?

• Der Fehler liegt in Deiner `toUpper` Funktion. Bei der innersten Schleife gehst du bis maxLength, obwohl das den gewünschten Speicherbereich überschreitet. Wenn du `maxLength` durch `strlen (bufferUp[i])` ersetzt, funktioniert's.

Ich glaube auch, dass du einen kleinen Denkfehler drin hast. Bei der Deklaration von buffer0 und buffer1, sind die 500 nicht die maximale Länge eines Wortes, sondern die Größe des Arrays, sprich: Ein Array mit 500 Elementen vom Typ 'Zeiger auf Character'.

So, jetzt noch ein paar grundlegende Dinge:

- Überprüfe, ob wirklich Speicher aloziert wurde (Rückgabewert von `calloc` )
- Keine Hartkodierten Typen in `calloc` etc.
- Zu jedem `calloc` ein `free`

Guckst du hier: Dynamischer Speicher mit malloc/calloc/realloc/free

• Danke!!

@monstermunchkin: Was meinst du mit "Keine Hartkodierten Typen in calloc etc."?

Ich habe jetzt den grundsätzlichen Fehler (Speicherüberschreiter) mittels strlen(buffer0[j]) behoben. Dennoch ist die Ausgabe nicht korrekt. Es werden im Array buffer1 plötzlich Groß- und Kleinbuchstaben vermischt, was mir noch komischer und fast noch unlogischer vorkommt als zuvor.

Die Ausgabe ist:

``````TEST                //korrekte Ausgabe
Test
-------------
HALLo               //korrekte Ausgabe
Hallo
-------------
WAS weiss ich       //hier wurden nicht alle Buchstaben groß gemacht
was weiss ich
-------------
PROGrammieren       //hier wurden nicht alle Buchstaben groß gemacht
Programmieren
-------------
TESTprogramm        //hier wurden nicht alle Buchstaben groß gemacht
Testprogramm
-------------
MACH was            //hier wurden nicht alle Buchstaben groß gemacht
Mach was
-------------
``````

• Max222 schrieb:

Danke!!

@monstermunchkin: Was meinst du mit "Keine Hartkodierten Typen in calloc etc."?

Beispiel:
- Hardkodiert: `buffer0[0] = calloc(strlen(word0), sizeof(char));`
- nicht Hardkodiert: `buffer0[0] = calloc(strlen(word0), sizeof *buffer0[0]);`

Steht übrigens auch im ANSI C FAQ, siehe Link, den ich gepostet hab.

Max222 schrieb:

Ich habe jetzt den grundsätzlichen Fehler (Speicherüberschreiter) mittels strlen(buffer0[j]) behoben. Dennoch ist die Ausgabe nicht korrekt. Es werden im Array buffer1 plötzlich Groß- und Kleinbuchstaben vermischt, was mir noch komischer und fast noch unlogischer vorkommt als zuvor.

Die Ausgabe ist:

``````TEST                //korrekte Ausgabe
Test
-------------
HALLo               //korrekte Ausgabe
Hallo
-------------
WAS weiss ich       //hier wurden nicht alle Buchstaben groß gemacht
was weiss ich
-------------
PROGrammieren       //hier wurden nicht alle Buchstaben groß gemacht
Programmieren
-------------
TESTprogramm        //hier wurden nicht alle Buchstaben groß gemacht
Testprogramm
-------------
MACH was            //hier wurden nicht alle Buchstaben groß gemacht
Mach was
-------------
``````
``````void toUpper(char *bufferUp[], int elements, int maxLength)
{
int i,j;
for (i=0; i<elements; i++) {
for (j=0; j<strlen (bufferUp[i]); j++) {
bufferUp[i][j] = toupper(bufferUp[i][j]);
}
}
}
``````

Das funzt ohne Probleme. Das 3. Argument kannst du aber weglassen, da es eh nicht verwendet wird.

• Tausend Dank!! Es funktioniert
Ich hatte dämlicherweise den falschen Index in strlen(bufferUp[i]) verwendet (j anstelle von i)...