Zum Inhalt springen

strcpy nachprogrammieren


Empfohlene Beiträge

Geschrieben

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;

}

Geschrieben
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.

Geschrieben
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.

Geschrieben

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".

Geschrieben

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 :-)

Geschrieben
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. :D

Geschrieben
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;
}

Geschrieben

zitat:

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

void main ()

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

int main!

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

Geschrieben

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

Geschrieben

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??

Geschrieben

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

Geschrieben
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*

Geschrieben

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

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...