Funktion strcat selbst schreiben

[bruecksy]

Hey,

ich soll eine Funktion erstellen, die sich genau wie die Bibliotheksfunktion strcat verhält, ohne auf eine Bibliotheksfunktion zurückzugreifen.
Ich habe eine Funktion definiert und sie in der main-Funktion getestet.
Jedoch bin ich leider noch auf strlen angewiesen...
Hat jemand von euch dazu eine gute Idee?

#include <stdio.h>

char *string_cat(char v[], char w[]) {
        int i = 5, j = 0;
        while(i <= 9) {
                v[i] = w[j];
                j++;
                i++;
        }
        return v[i];
}

int main(void)
{
        char v[10] = "Danke";
        char w[5] = "sehr";
        string_cat(v, w);
        printf("%s", v);
        return 0;
}

[Swordfish]

Schreibe bitte in eine Zeile vor Deinen Code ``` und in eine Zeile nach deinem Code ```. Alternativ markiere Deinen Code und klicke auf das </> in der Symbolleiste über dem Eingabefeld.
Du kannst Deine Beiträge auch im nachhinein bearbeiten. Den Menüpunkt "Bearbeiten" findest Du in dem Drei-Punkte-Menü rechts unter Deinen Beiträgen.

[DocShoe]

Die erste gute Idee ist deinen Code in CodeTags einzuschließen, damit man ihn vernünftig lesen kann. Dazu findest du über der TextBox das </> Symbol. Das erzeugt dir die umschließenden Tags, du musst dann nur noch deinen Code einfügen.

[bruecksy]

@Swordfish Danke dir!

[Swordfish]

@bruecksy sagte in Funktion strcat selbst schreiben:

return v[i];

Das kann schoneinmal nicht sein. v[i] ist ein char. Deine Funktion verspricht aber einen Pointer to char zurückzugeben.

[DocShoe]

Im ersten Schritt musst du halt das Ende des ersten Strings finden. Fang bei Index 0 an und such´ so lange weiter, bis du eine 0x00 gefunden hast. Anschließend hängst du halt so lange die Zeichen des zweiten strings an den ersten an, bis du auch da eine 0x00 gefunden hast. Oder du implementierst die strlen Funktion selbst, das ist ein Einzeiler.
Die char[] Notation als Funktionsparameter ist zwar korrekt, finde ich aber iwie verwirrend. AFAIK ist strcat mit char* deklariert, das finde ich einleuchtender.

[Swordfish]

Klassisch macht man das so:

char* strcat(char *dst, char const *src)
{
    char *result = dst;
    while (*dst)
        ++dst;
    while (*dst++ = *src++);
    return result;
}

[Swordfish]

@DocShoe sagte in Funktion strcat selbst schreiben:

Im ersten Schritt musst du halt das Ende des ersten Strings finden. Fang bei Index 0 an und such´ so lange weiter, bis du eine 0x00 gefunden hast.

Was im Prinzip strlen() ist:

size_t strlen(char const *str)
{
    char const *ori = str;
    while (*str++);
    return str - ori - 1;
}

[bruecksy]

@Swordfish, also müsste ich zwei Funktionen erstellen? Kann ich eine verschachtelte Schleife nutzen?

[Swordfish]

Die erste while-Schleife in meinem strcat() oben ist der strlen()-Ersatz. So lange den Zeiger auf das Ziel erhöhen bis man die '\0' gefunden hat.

Das ganze in grün mit Indizes:

char *strcat(char *dst, char const *src)
{
    size_t dst_index = 0;
    while (dst[dst_index])
        ++dst_index;
    size_t src_index = 0;
    while (dst[dst_index++] = src[src_index++]);
    return dst;
}

[bruecksy]

@Swordfish Warum muss ich den Rückgabetyp size_t verwenden?

[Swordfish]

@bruecksy Du meinst bei strlen()? Was würdest Du nehmen?

(Du brauchst strlen() garnicht nehmen, das war mehr eine nice to know Zusatzinfo)

[bruecksy]

@Swordfish bei dst_index und src_index

[Swordfish]

Oh wie peinlich, ja ... lach. Weil size_t garantiert groß genug für jedes Objekt ist:

size_t:

size_t can store the maximum size of a theoretically possible object of any type (including array).
size_t is commonly used for array indexing and loop counting. Programs that use other types, such as unsigned int, for array indexing may fail on, e.g. 64-bit systems when the index exceeds UINT_MAX or if it relies on 32-bit modular arithmetic.

[bruecksy]

@Swordfish siehs mir halt nach

[Swordfish]

@bruecksy Peinlich für MICH weil ich nicht gerafft habe welche Stelle Du meintest. Mehr Selbstvertrauen Brudi.

@Swordfish sagte in Funktion strcat selbst schreiben:

    while (dst[dst_index++] = src[src_index++]);

Du kannst das natürlich auch langatmiger schreiben:

    while (dst[dst_index] = src[src_index]) {
        ++dst_index;
        ++src_index;
    }

Die Zuweisung ist im Schleifenkopf damit auch die '\0' mitkopiert wird.

Wenn die Aufgabe war strcat() zu schreiben war doch sicher die vorhergehende Aufgabe strcpy() zu schreiben? Wie sieht denn das bei Dir aus?

[bruecksy]

@Swordfish ne die vorherige war strcmp()... die sieht bei mir so aus:

int string_compare(char v[], char w[]) {
        int a;
        int i = 0;
        while (i < v[i]) {
                if(v[i] < w[i]) {
                        a = -1;
                } else if (v[i] > w[i]) {
                        a = 1;
                } else {
                        a = 0;
                }
                ++i;
        }
        return a;
}

[Swordfish]

Dann mach mal strcpy(). Ist ja kein Aufwand.

[Swordfish]

@bruecksy sagte in Funktion strcat selbst schreiben:

while (i < v[i])

Kannst Du mir das bitte erklären?

[bruecksy]

@Swordfish
der ganze Code

int string_compare(char v[], char w[]);

int main(void)
{
        char v[5] = "test";
        char w[5] = "test";
        printf("%i", string_compare(v, w));
        return 0;
}

int string_compare(char v[], char w[]) {
        int a;
        int i = 0;
        while (i < v[i]) {
                if(v[i] < w[i]) {
                        a = -1;
                } else if (v[i] > w[i]) {
                        a = 1;
                } else {
                        a = 0;
                }
                ++i;
        }
        return a;
}

[Swordfish]

Ja ne, erklär' mir bitte Deinen Gedankengang bei
@bruecksy sagte in Funktion strcat selbst schreiben:

while (i < v[i])

Mein strcmp():

int strcmp(char const *lhs, char const *rhs)
{
    while ((*lhs && *rhs) && (*lhs == *rhs))  // 1)
        ++lhs, ++rhs;
    return (char unsigned)*lhs - (char unsigned)*rhs;
}

1) läuft solange beide Dingstis noch nicht am Ende sind (*lhs && *rhs ... kurz für *lhs != '\0' && *rhs != '\0') und die Zeichen gleich sind (*lhs == *rhs).
Danach braucht man bloß noch subtrahieren.