Funktion strcat selbst schreiben

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

[bruecksy]

@Swordfish
Da v und w gleich viele Komponenten besitzen, ist in v[5] und w[5] die binäre Null gespeichert. Die ersten vier Komponenten werden bezüglich der lexikographischen Ordnung miteinander verglichen. In diesem Beispiel wird 0 ausgegeben, da sich die Komponenten nicht voneinander unterscheiden

[Swordfish]

@bruecksy Was hat denn der Index mit dem Zeichen zu tun? Du vergleichst i < v[i] ...

@bruecksy sagte in Funktion strcat selbst schreiben:

Da v und w gleich viele Komponenten besitzen

Das hat deine Funktion nicht zu interessieren. Die muss für ALLE MÖGLICHEN Eingaben passen.

Nur zur Erinnerung:

strcmp():

Compares two null-terminated byte strings lexicographically.

The sign of the result is the sign of the difference between the values of the first pair of characters (both interpreted as unsigned char) that differ in the strings being compared.

The behavior is undefined if lhs or rhs are not pointers to null-terminated byte strings.

Also: Stelle finden an der sich die beiden Strings unterscheiden oder zuende sind und dann subtrahieren. Fertig.