toupper-Funktion mit Pointer

Wenn du einen einfachen Zeiger hast wie char * destination , kannst du auf den Inhalt mit [] oder mit * zugreifen.

<-> bedeutet: "ist das Gleiche wie"

destination[0] <-> *destination
destination[1] <-> *(destination+1)

Dein return &destination[0]; ist im Prinzip richtig gedacht, aber zu kompliziert, da

&destination[0] <-> destination

Dein *destination hat keinen Speicherplatz, darum dürfte das Programm abstürzen.
Im einfachsten Fall legst du ein Array an, das groß genug ist, um str bzw. source aufzunehmen.

char destination[256] = {0};

oder

char destination[sizeof(str)] = {0};

Hallo,

vielen Dank für eure Hilfe!
@DirkB - Danke das du mir das mal so klar aufgeschlüsselt hast, jetzt ergibt das alles wieder ein bisschen mehr Sinn.
@cooky451- Danke dir, aber das mit der Pointerarithmetik überlass ich erstmal denen die schon ohnen Stützräder fahren können
@ CStoll- Danke, ich glaub auch gerade dadrin liegt mein Problem.

char * strtoupper (char * destination, const char * source)
{
  int x =0;

 while (source[x] != '\0')
 {
   destination=source[x];
   destination[x]=(char)toupper(*destination);
   ++x;  
 }
  return &destination[0];

}

Meine Werte werden hier immerwieder von chars in int umgemodelt. Stimmt doch, dass die int dann die Speicheradressen sind und eben die chars meine Strings. Aber wie genau geht das hier ab?!?

Gruß

cooky451

Du solltest den Parameter für toupper() noch einmal überdenken.

zwerg1221 schrieb:

Stimmt doch, dass die int dann die Speicheradressen sind und eben die chars meine Strings.

Ein char ist immer nur ein Zeichen, welches nichts anderes ist als eine Zahl.
Folgendes ist problemlos möglich:

int i = 'c;
char c = i;

den Wert von src[x] zu um dann zu schreiben:

= toupper(dest[x]);

Fürs Pointer gucken:

void foo(char *dest, const char *src)
{
  while (*src != '\0')
    *dest++ = toupper(*src), ++src;
  *dest = *src;
}

Wutz

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

char * strtoupper (char * destination, const char * source)
{
int x =0;

while (source[x] != '\0')
{
destination[x]=toupper(source[x]);
++x;
}

return &destination[0];
}

int main()
{

char str[]="inPut", destination[1000], *source;
source=str;

strtoupper(destination,source);

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

return 0;
}

Welche Schulnote wäre dieses funktionierende und weil auf deinem Code basierend nicht optimale Beispiel wert?

char* str_toupper(char* src, char* dest)
{
	int i = 0;
	while(src[i] != 0)
		dest[i] = toupper(src[i++]);
	return dest;
}

CStoll

zwerg1221 schrieb:

destination=source[x];
   destination[x]=(char)toupper(*destination);
   ++x;  
}

Das Ding kann so nicht funktionieren - du überschreibst die Zieladresse mit einem Zahlen- bzw. ASCII-Wert und nutzt diesen dann als Adresse, um den Zielwert zu ermitteln. Wenn du schon einen Zwischenspeicher verwenden willst, dann nimm dafür eine char-Variable:

char temp = source[x];
destination[x] = toupper(temp);

// oder noch kürzer
destination[x] = toupper(source[x]);

src schrieb:

char* str_toupper(char* src, char* dest)

Schau dir mal die Reihenfolge der Parameter bei den Funktionen aus string.h an.
Da steht das Ziel an erster Stelle.
Nach dem Motto Ziel = Quelle , sollte der Aufruf auch str_toupper(Ziel, Quelle) sein.

DirkB schrieb:

char* str_toupper(char* src, char* dest)
...
Da steht das Ziel an erster Stelle.

http://de.pons.eu/dict/search/results/?l=deen&q=source
http://de.pons.eu/dict/search/results/?l=deen&q=destination

Hallo,
vielen Dank euch allen!!! Da hab ich jetzt erstmal was zum dran anknüpfen und werd ne Weile brauchen, bis ich dass jetzt implementiert hab.

cooky451 schrieb:

den Wert von src[x] zu um dann zu schreiben:

= toupper(dest[x]);

[/cpp]

Haha jede Woche ein neuer Klassiker; letzte Woche habe ich den hier verbrochen

for (i=0; i < N; ++i) 
   {for (j=0; j< i; ++j)
      {if (i == j)	
	  spur += V[i][j];

und habe mich ewig++ gewundert, warum da immer 0 rauskommt .

my oh my schrieb:

DirkB schrieb:
char* str_toupper(char* src, char* dest)
...
Da steht das Ziel an erster Stelle.

Das char* str_toupper(char* src, char* dest) stammt von src, nicht von mir!

Hallo Leute,
nachdem ich es jetzt dank eurer Hilfe ein wenig mehr begriffen habe und einiges dazu programmiert habe, hänge ich wieder an der selben Stelle fest. Diesmal wird mein Wort groß ausgegeben aber auf wundersame Weise werden immer zwei Zeilen dazu gepackt und ab und zu mit irgendwelchen zufälligen Dingen beschrieben. Ich versteh einfach nicht warum.
Vielleicht kann jemand nochmal einen Blick drüber werfen, oder kennt den Fehler.

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

#define MAX 100

char * strtoupper (char * destination,  char * source) /*Funktion zur "Großstellen eines char */
{
  int x =0;
 while (*source != '\0')
 {
   *destination++ = toupper(*source++);

 }
  return &destination[0];

}
char * strinv (char * destination, const char * source)

{
 {
  destination += strlen(source);
  *destination=0;
  while (*source)
    *(--destination)=*source++;
}
return &destination[0];
}

main()

{
char destination[MAX], *source, str[MAX], str1[MAX], str2[MAX];

printf( " Bitte string eingeben: ");
fgets(str,MAX,stdin);
source=str;

strtoupper(str1,source);
printf("%s\n",str1);
source=str1;
strinv(str2,source);
printf("%s\n",str2);
}

Vielen Dank

Gruß

cooky451

Deine Funktion kopiert das '\0' nicht, zudem ist "return &destination[0]" sinnlos, da destination jetzt nur noch auf ein '\0' zeigt. Entweder ne void Funktion draus machen oder den Anfang zwischenspeichern.

Du musst bi strtoupper die '\0' am Ende vom String mit kopieren.
Außerdem ist das &destination[0]; zu viel des Guten.
Ein einfaches destination reicht da vollkommen.

CStoll

Du hast beim Übertragen der Strings vergessen, den Null-Terminator im Zielstring zu setzen.

PS: Das Gebastel mit dem source-Pointer in der main() ist unnötig und das Array destination nimmt nur Platz weg.

Bei strinv hat er doch durch

destination += strlen(source);
*destination=0;

die '\0' eingebaut. Und die '\0' aus source kopiert er nicht mit.

CStoll

DirkB schrieb:

Bei strinv hat er doch durch
destination += strlen(source);
*destination=0;
die '\0' eingebaut. Und die '\0' aus source kopiert er nicht mit.

Aber dort wird als Quelle das Ergebnis des strtoupper()-Aufrufs verwendet - Garbage In, Garbage Out

CStoll schrieb:

Garbage In, Garbage Out

Ist schon klar. Aber immer noch besser als Garbage In -> Absturz.
Obwohl das bei solchen Fehlern auch passieren kann.

Hallo,
danke jetz hab ichs gesehen, ein wenig gegrübelt und wieder etwas mehr verstanden. Muss dazu sagen, dass ich hier einige Bücher rumfahren habe, da ist schon allein aus Zeitgründen einiges abgeschaut. Aber das

while (*source != '\0')

war auf meinem Mist gewachsen

DirkB schrieb:

Bei strinv hat er doch durch
destination += strlen(source);
*destination=0;
die '\0' eingebaut. Und die '\0' aus source kopiert er nicht mit.

Danke dafür und allen anderen auch!!!
Schöne Woche!

Gruß