toupper-Funktion mit Pointer

Hallo liebe Forum-Gemeinde,
ich beschäftige mich mehr oder weniger freiwillig erst seit kurzem mit C und komm bei einer (sollte eigentlich ziemlich leicht sein ) Aufgabe nicht weiter.

Und zwar soll ein const char * source z.B. StrandUrlaub einfach mit Hilfe von toupper in destination gespeichert werden werden. Soweit so gut, doch leider soll dies in einer Funktion geschehen und diese soll als Rückgabewert die Adresse von destination liefern.

Ich hab das mal so probiert:

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

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

!= '\0')

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

return &destination[0];

}
main()
{

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

strtoupper(*destination,*source);

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

}

Ihr seht bestimmt, dass ich da komplett auf dem Schlauch stehe. Ich komm mit diesen Pointern einfach noch nicht zurecht, obwohl ich schon den ganzen Tag am Bücher welzen bin.

Über Hilfe wär ich sehr dankbar.
Vielen Dank
Gruß

CStoll

In den Index-Zugriffen steckt schon eine Dereferenzierung drin, da brauchst du nicht nochmal zu dereferenzieren - sprich: lass bei den ganzen *destination[x] die Sterne weg. Außerdem solltest du in der while-Schleife lieber auf den Quell-String vergleichen.

PS: sfds

cooky451

Und hier lässt sich eigentlich wunderbar die Pointerarithmetik ausnutzen.

void foo(char *p)
{
  // p zeigt gleich auf p[1] ;)
  p++;
}

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.