ft_strlcat.c

Esta función permite concatenar cierta cantidad de caracteres de una cadena a otra.

Enunciado

strlcat(3)

NOMBRE
    strlcat --> concatena una cantidad especifica de caracteres de una cadena a otra 
CABECERA
    size_t strlcat(char *dst, const char *src, size_t sz);
DESCRIPCIÓN
    Concatena `sz - 1` caracteres de la cadena de orígen `src` hacia la de destino `dst`.
DEVOLUCIÓN
    Devuelve la longitud total de la cadena que intentará crear.

Esta función, es bastante simple, pero hay que tener en cuenta que la cadena siempre terminará en 'NULL`.

Si se proporciona una longitud suficiente para teminar la cadena sin acortarla, lo horá. En caso contrario, se copiará sz - 1 y se añadirá posteriormente el carácter núlo al final de la cadena.

Planteamiento

ft_strlcat.c

#include "libft.h"

size_t ft_strlcat(char *dst, const char *src, size_t sz) {
    /* en este caso, hemos utilizado cuatro variables auxiliares */
    /* definimos una variable auxiliar para cada uno de los punteros objetivos, tanto `dst` como `src`. Estos nos ayudarán a guardar la longitud original del puntero `src` */
    if (/* el tamaño a copiar es mayor a `0` o es menor igual a la longitud de `dst` */)
        return (/* la longitud de `src` sumada a `sz` */)
    while(/* la posición actual de `src`sea diferente a null y el mismo contador utilizado, sea menor igual a (`sz` + (la longitud de destino - 1)) */) {
        /* establecemos el valor de la posición actual de `dst` al carácter actual de `src` */
        /* preparamos la siguiente iteración */
    }
    /* añadimos el carácter núlo al final de la cadena */
    /* bajo cualquier caso, devolveremos la longitud original de `src` + la longitud de `dst` */
    return (/* contenido return */);
}

Solución

Recuerda: para entregar tu proyecto, debes poder defenderlo. Por ello, resuelve cada enunciado con la respuesta que te parezca mas entendible a nivel presonal.

J: "No hay respuestas incorrectas, solo puntos de vista distantes".

Solución Base

ft_strlcat.c

#include "libft.h"

size_t ft_strlcat(char *dst, const char *src, size_t sz) {
    /* en este caso, hemos utilizado cuatro variables auxiliares
     * utilizaremos dos de ellas para guardar la longitud original de las cadenas */
    stze_t x;
    size_t y;
    size_t src_len;
    size_t dst_len;
    
    x = 0;
    y = ft_strlen(dst);
    src_len = ft_strlen(src);
    dst_len = y;
    /* si el tamaño a copiar es mayor a `0` o es menor igual a la longitud de `dst` */
    if (sz < 0 || sz <= dest_len)
        /* devolvemos la longitud de `src` sumada a la de `sz` */
        return (src_len + sz);
    /* mientras la posición actual de `src`sea diferente a null y el mismo contador utilizado, sea menor igual a (`sz` + (la longitud de destino - 1)) */
    while(src[x] != '\0' && x <= (sz + dest_len - 1)) {
        /* establecemos el valor de la posición actual de `dst` al carácter actual de `src` */
        dst[x] = src[y];
        /* preparamos la siguiente iteración */
        x++;
        y++;
    }
    /* añadimos el carácter núlo al final de la cadena */
    dst[y] = '\0';
    /* bajo cualquier caso, devolveremos la longitud original de `src` + la longitud de `dst` */
    return (src_len + dest_len);
}

Solución Óptima

ft_strlcat.c

#include "libft.h"

size_t ft_strlcat(char *dst, const char *src, size_t sz) {
    /* en este caso, hemos utilizado dos variables auxiliares, para guardar la longitud original de las cadenas */
    size_t src_len;
    size_t dst_len;
    
    src_len = ft_strlen(src);
    dst_len = ft_strlen(dest);
    /* si el tamaño a copiar es mayor o igual a la cantidad que queremos concatenar */
    if (dst_len >= sz)
        /* establecemos la longitud de `dst` al valor de `sz` */
        dst_len = sz;
    /* en caso de que la longitud de `dst` sea igual a `sz`, devolvemos directamente */
    if (dst_len == sz)
        return (dst_len + src_len);
    /* en cso de que `sz` sea mayor a la longitud de `src` aún restando `sz` */
    if (src_len < (sz - dst_len))
        /* copiamos el contentido de src con un máximo de (`sz` + 1) */
        ft_memcpy(dst + dst_len, src, src_len + 1);
    else {
        ft_memcpy(dst + dst_len, src, sz - dst_len - 1);
        dst[sz - 1] = '\0';
    }
    /* bajo cualquier caso, devolveremos la longitud original de `src` + la longitud de `dst` */
    return (src_len + dest_len);
}