was ist hieran falsch und warum?

#include <stdio.h>

#include <string.h>

int ownstrcpy(*zielstring,*quellstring);

void main ()

{

char zielstring[255], quellstring[255],buffer[255];

gets(quellstring);

ownstrcpy(*zielstring,*quellstring);

printf("quellstring: %s\nzielstring: %s\n!",quellstring,zielstring);

gets(buffer);

}

int ownstrcpy(*zielstring,*quellstring)

{

int i=0,len=0;

len=strlen(*quellstring);

for(i;i<=len;i++)

{

*quellstring = *zielstring;

}

return 0;

}

Original geschrieben von GMKai

was ist hieran falsch und warum?

int ownstrcpy(*zielstring,*quellstring)

{

int i=0,len=0;

len=strlen(*quellstring);

for(i;i<=len;i++)

{

*quellstring = *zielstring;

}

return 0;

}

Du weist der Quelle (in die du mit gets eingelesen hast), den "leeren" Zielstring zu.

Richtig wäre: *zielstring = *quellstring;

Gruß Pönk

PS: Du könntest/Solltest den "Fehler" beim nächsten mal ruhig einwenig ausführlicher beschreiben.

int ownstrcpy(*zielstring,*quellstring);

Falsche Typen für die Parameter, der erste muss char* sein, der zweite const char *.

strcpy gibt char* zurück, nicht int.

void main ()

int main!

ownstrcpy(*zielstring,*quellstring);

Warum die Sternchen? und warum willst du Arrays mit uninitialisiertem Inhalt kopieren?

int ownstrcpy(*zielstring,*quellstring)

Falsche Typen für die Parameter und Rückgabewert, siehe oben

len=strlen(*quellstring);

Warum das Sternchen?

*quellstring = *zielstring;

Auch hier, warum die Sternchen?

Außerdem, wie Pönk bereits sagte, falsche Richtung der Zuweisung.

return 0;

strcpy gibt den ersten Parameter zurück.

habs jetzt so geändert:

#include <stdio.h>

#include <string.h>

char ownstrcpy(char *zielstring,const char *quellstring);

int main ()

{

char zielstring[255], quellstring[255],buffer[255];

gets(quellstring);

ownstrcpy( zielstring, quellstring);

printf("quellstring: %s\nzielstring: %s\n!",quellstring,zielstring);

gets(buffer);

return 0;

}

char ownstrcpy(char zielstring,const char quellstring)

{

int i=0,lenght=0;

lenght=strlen(quellstring);

for(i;i<=lenght;i++)

{

zielstring = quellstring;

}

return 0;

}

die rückgabewerte sind laut aufgabenstellung in ordnung.

probleme gibts noch in den zeilen 19 und 22.

als fehler gibts nur "invalid".

die musterlösung könnte so aussehen:

#include <stdio.h>

#include <string.h>

char ownstrcpy(char *zielstring,const char *quellstring);

int main ()

{

char zielstring[255], quellstring[255],buffer[255];

gets(quellstring);

ownstrcpy( zielstring, quellstring);

printf("quellstring: %s\nzielstring: %s\n",quellstring,zielstring);

gets(buffer);

return 0;

}

char ownstrcpy(char *zielstring,const char *quellstring)

{

int i=0,lenght=0;

lenght=strlen(quellstring);

for(i;i<=lenght;i++)

{

zielstring = quellstring;

}

return 0;

}

an die helfer vielen dank, und die drohung, ich melde mich wieder :-)

char *strcpy(char *dst, const char *src)

{

   char *s = src;

   char *d = dst;

   while (*s != '\0') *d++ = *s++;

   return dst;

}

Original geschrieben von M.A.Knapp

char ownstrcpy(char *zielstring,const char *quellstring)

{

int i=0,lenght=0;

lenght=strlen(quellstring);

for(i;i<=lenght;i++)

{

zielstring = quellstring;

}

return 0;

}

Hmm,

for( int i=0; i<=strlen(quellestring);++i )

{

...

}

sollte reichen und sieht besser aus.

an die helfer vielen dank, und die drohung, ich melde mich wieder :-)

Keine Panik - helfen gern auch wenn ich diesmal einwenig zu spät war und nicht helfen konnten.

Original geschrieben von M.A.Knapp

char *strcpy(char *dst, const char *src)

{

   char *s = src;

   char *d = dst;

   while (*s != '\0') *d++ = *s++;

   return dst;

}

[/code]
 [/b] 

s brauchst du nicht, du könnstest src direkt verwenden. Aber du solltest auf jeden Fall noch das Nullzeichen mit kopieren:



[code]char *strcpy(char *dst, const char *src)

{

   char *d = dst;

   do {

      *d++ = *src;

   } while(*src++);

   return dst;

}

zitat:

--------------------------------------------------------------------------------

void main ()

--------------------------------------------------------------------------------

int main!

Also darüber lässt sich streiten. Auf einem Embedded System wäre "int main" Unsinn.

Hallo,

Original geschrieben von DingDong

Also darüber lässt sich streiten. Auf einem Embedded System wäre "int main" Unsinn.

Nein, läßt sich nicht. Der Standard ist an dieser Stelle eindeutig (Referenz: ANSI Sec. 2.1.2.2.1, Sec. F.5.1 oder jede C-FAQ!). Die Fourmssuche sollte auch einiges zu Tage führen.

Nic

hier ist mal meine Lösung für die funktion:

char*strkopie(char*b,const char*a)

{

int i;

for(i=0;i<strlen(b+1);i++)

{

b=a;

}

return b;

}

Hallo,

Original geschrieben von MoechtegernFI

for(i=0;i<strlen(b+1);i++)

Na, das wird nicht funktionieren (Du addierst 1 auf den Pointer und ermittelst dann die Länge).

Nic

hmm, kann sein....will mich nich von nem Fehler freisprechen aber es funzt...

Das Ergebnis von strlen(a+1) müsste das gleiche sein wie von strlen(a) - 1.

Weil wenn man auf den Pointer 1 drauf addiert, fällt lediglich der erste char im Array weg.

Einen Pointer mit +1 oder ++ zu erhöhen gibt liefert immer den Pointer zum nächsten Objekt im array.

Bei char* a; nehmen wir mal an a wäre dann 0x0123, nach ++ wäre a dann 0x0124.

Bei int* a; wäre a nach ++ dann 0x0127, weil ein integer ja 4 Byte lang ist.

Stimmts??

Das stimmt so nicht. Hier wird nur zufällig das nächte Element im Array geliefert

weil 1 char 1Byte groß ist (glaube ich zumindest:rolleyes: ).

Hallo,

Original geschrieben von FinalFantasy

Das Ergebnis von strlen(a+1) müsste das gleiche sein wie von strlen(a) - 1.

Dem ist nicht so. Man sollte immer die Grenzfälle mit in Betracht ziehen. Schau Dir mal das Verhalten der Funktion an, wenn Du einen Leerstring übergibst! In dem Fall würde strlen() versuchen, ab dem ersten Zeichen nach dem eigentlichen String-Ende die Länge zu ermitteln.

Hier noch eine Lösung für das Ursprungsproblem:

char * strcpy(char * dest,const char *src)

{

	char *tmp = dest;

	while ((*dest++ = *src++) != '\0');

	return tmp;

}

Nic

Original geschrieben von Guybrush Threepwood

Das stimmt so nicht. Hier wird nur zufällig das nächte Element im Array geliefert

weil 1 char 1Byte groß ist (glaube ich zumindest:rolleyes: ).

Eben genau das meinte ich ja. Das Increment/Decrement auf einen Pointer erhöht/verringert diesen immer um size_of(von seinem Datentyp).

Da bin ich mir ziemlich sicher. Bei ++ zumindest, bei a = a + 1, nicht so ganz

Natürlich wirft das Probleme auf, falls man einen Leerstring übergibt. Drum würde ich auch sowas nicht verwenden, sondern dann doch lieber strlen(a) - 1, und dann nochmal abfragen, ob das ergebnis kleiner als 0 ist.

Aber meine Antwort war eher im Sinne der Pointer-Arithmetik gedacht, was C ja grad so lustig macht. *gg*

Hallo,

Das Ergebnis von strlen(a+1) müsste das gleiche sein wie von strlen(a) - 1.

Auch im Sinne der Pointer-Arithmetik ist Fakt, dass diese Aussage schlicht und erfgreifend falsch ist. Es ist ein eklatanter Unterschied, ob strlen() einen Core-Dump produziert oder ein korrektes Ergebnis liefert.

Da bin ich mir ziemlich sicher. Bei ++ zumindest, bei a = a + 1, nicht so ganz

Ist synonym. Die Zeigerarithmetik ist integraler Bestandteil der Sprache und einheitlich definiert.

Nic