42 - Libft

Yayın: 26 Mart 2025 | Yazar: Derya Acar

`libft`, standart C kütüphanesindeki bazı temel işlevlerin nasıl çalıştığını anlamak için bir fırsat sunar. Genellikle, bu işlevleri yeniden uygulamak ve kendi kütüphanenizi oluşturmak için temel bir alıştırma olarak kullanılır. Bu işlevler, bellek işlemleri, dize manipülasyonu, karakter işlemleri ve listeler gibi çeşitli alanlara yayılmıştır.

1 - Bellek İşlemleri

Bu işlevler, genellikle bellek alanının manipülasyonu ve işlenmesi gereken durumlarda kullanılır. Örneğin, bir dizi içinde belirli bir değerin aranması, bellek alanının belirli bir değerle doldurulması veya bellek bloklarının karşılaştırılması gibi işlemlerde bu fonksiyonlara ihtiyaç duyulur.

💡 Örnek Kod:


    void	*ft_calloc(size_t count, size_t size)
    {
        void	*ptr;
                
        ptr = malloc(size * count);
        if (!(ptr))
            return (NULL);
        ft_bzero(ptr, (count * size));
        return (ptr);
    }

💡 Örnek Kod:


    void	ft_bzero(void *s, size_t n)
    {
        ft_memset(s, 0, n);
    }

Açıklama: ft_memset işlevini çağırır ve bu işlev aracılığıyla bellek bloğunu 0 ile doldurur. Yani, ft_bzero aslında ft_memset fonksiyonunu çağırmakla görevlidir.

💡 Örnek Kod:


    void	*ft_calloc(size_t count, size_t size)
    {
        void	*ptr;
                        
        ptr = malloc(size * count);
        if (!(ptr))
                return (NULL);
        ft_bzero(ptr, (count * size));
        return (ptr);
   }

Açıklama: ft_calloc, bellek tahsis eder ve ardından bu bellek alanını sıfırlar. Bu işlev, genellikle dinamik bellek yönetimi için kullanılır.

💡 Örnek Kod:


    void	*ft_memcpy(void *dst, const void *src, size_t n)
    {
        size_t	i;
                
        if (!dst && !src)
            return (0);
        i = 0;
        while (i < n)
        {
            ((unsigned char *)dst)[i] = ((unsigned char *)src)[i];
            i++;
        }
        return (dst);
    }

Açıklama: ft_memcpy, bir bellek bloğunu başka bir bellek bloğuna kopyalar. Bu işlev, genellikle veri kopyalama işlemleri için kullanılır.

💡 Örnek Kod:


    void	*ft_memmove(void *dst, const void *src, size_t n)
    {
        if (!dst && !src)
            return (NULL);
        if (dst < src)
            ft_memcpy(dst, src, n);
        else if (dst > src)
        {
            while (n--)
                *((unsigned char *)(dst + n)) = *((unsigned char *)(src + n));
        }
        return (dst);
    }

Açıklama: ft_memmove, bir bellek bloğunu başka bir bellek bloğuna güvenli şekilde taşır. Bellek alanları çakışsa (overlap) bile veri kaybı olmadan çalışır; bu yönüyle ft_memcpy'den farklıdır.

💡 Örnek Kod:


    void	*ft_memchr(const void *s, int c, size_t n)
    {
        const unsigned char	*str;
                        
        str = s;
        while (n > 0)
        {
            if (*str == (unsigned char) c)
                return ((void *)str);
                n--;
                str++;
        }
        return (NULL);
    }

Açıklama: ft_memchr, bir bellek bloğunda belirli bir karakteri arar ve bulursa o karakterin adresini döner. Eğer karakter bulunamazsa NULL döner.

💡 Örnek Kod:


    int	ft_memcmp(const void *s1, const void *s2, size_t n)
    {
        const unsigned char	*s1_uc;
        const unsigned char	*s2_uc;
        size_t				index;
                        
        index = 0;
        s1_uc = (const unsigned char *)s1;
        s2_uc = (const unsigned char *)s2;
        while (index < n)
        {
            if (s1_uc[index] != s2_uc[index])
                return (s1_uc[index] - s2_uc[index]);
            index++;
        }
        return (0);
    }

Açıklama: ft_memcmp, iki bellek bloğunu karşılaştırır ve ilk farklı karakterin ASCII değerlerinin farkını döner. Eğer bloklar tamamen aynıysa 0 döner.

2 - Dize İşlemleri

Dize işlemleri, metinsel verilerin manipülasyonu ve işlenmesi için kullanılan işlevlerdir. Bu işlevler, bir dizenin uzunluğunu hesaplamak, başka bir dizeye kopyalamak, bir dizeye yeni karakterler eklemek, belirli bir karakteri bir dizide aramak, alt dize aramak veya iki dizeyi karşılaştırmak gibi çeşitli işlemleri gerçekleştirir.

💡 Örnek Kod:


    size_t ft_strlen(const char *str)
    {
        size_t len = 0;
        while (str[len] != '\0')
            len++;
        return len;
    }

Açıklama: ft_strlen, bir dizinin uzunluğunu hesaplar. Dizi sonuna kadar giderek karakterleri sayar ve son karakter olan null terminatörü ('\0') saymaz.