[C] Libft - Part1_Libc functions

is_functions

isalpha

int     ft_isalpha(int c)
{
        if (c >= 'a' && c <= 'z')
                return (2);
        else if (c >= 'A' && c <= 'Z')
                return (1);
        else
                return (0);
}

• 입력받은 int c가 ascii 코드로 알파벳인지 확인하여 소문자는 2, 대문자는 1, 알파벳이 아니면 0을 return 한다.

isdigit

int     ft_isdigit(int c)
{
        if (c >= '0' && c <= '9')
                return (c);
        else
                return (0);
}

• 입력받은 int c가 ascii 코드로 숫자인지('0'~'9') 확인하여 숫자면 0이 아닌 값을, 숫자가 아니면 0을 return 한다.

isalnum

int     ft_isalnum(int c)
{
       if (c >= '0' && c <= '9')
               return (c);
       else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
               return (c);
       else
               return (0);
}

• 입력받은 int c가 ascii 코드로 숫자인지('0'~'9') 혹은 알파벳인지 확인하여 숫자나 알파벳이면 0이 아닌 값을, 아니면 0을 return 한다.

isascii

 int     ft_isascii(int c)
{
        if (c >= 0 && c <= 127)
                return (1);
        else
                return (0);
}

• 입력받은 int c가 ascii 코드인지 확인하여 ascii코드면 1을, 아니면 0을 return 한다.

isprint

 int     ft_isprint(int c)
{
        if (c > 31 && c < 127)
                return (c);
        return (0);
}

• 입력받은 int c가 ascii코드 중 출력 가능한 문자면 0이 아닌 값을, 출력 불가능한 문자면 0을eturn 한다.

to_functions

toupper

int     ft_toupper(int c)
{
        if (c >= 'a' && c <= 'z')
                return (c - 32);
        return (c);
}

• 입력받은 int c가 소문자면 대문자로 변환하여 return 한다.

toupper

int     ft_tolower(int c)
{
        if (c >= 'A' && c <= 'Z')
                return (c + 32);
        return (c);
}

• 입력받은 int c가 대문자면 소문자로 변환하여 return 한다.

str_functions

strlen

size_t  ft_strlen(const char *s)
{
        unsigned int    i;

        i = 0;
        if (s[i] == '\0')
                return (0);
        while (s[i] != '\0')
                i++;
        return (i);
}

• 입력받은 *s의 스트링 길이를 구해서 반환한다.
• unsigned int를 0으로 초기화하여 while문으로 스트링의 끝까지 i++한 후 i를 return 한다.

strlcpy

size_t  ft_strlcpy(char *dst, const char *src, size_t size)
{
        size_t  i;
        size_t  s;

        i = 0;
        s = 0;
        while (src[s] != '\0')
                s++;
        if (size == 0)
                return (s);
        while (i + 1 < size && src[i] != '\0')
        {
                dst[i] = src[i];
                i++;
        }
        dst[i] = '\0';
        return (s);
}

• 입력받은 dst에 src를 size만큼 붙여 넣는다.
  size는 dst의 size를 말한다.
• retrun 값은 man strlcpy에 따르면 src의 길이를 말한다.

man strlcpy - return values
The strlcpy() and strlcat() functions return the total length of the stringthey tried to create.
For strlcpy() that means the length of src. 

strlcat

size_t  ft_strlcat(char *dst, const char *src, size_t size)
{
        size_t  dst_l;
        size_t  src_l;
        size_t  i;
        size_t  j;

        if (!dst && size == 0)
                return (0);
        j = 0;
        src_l = ft_strlen(src);
        dst_l = ft_strlen(dst);
        if (size <= dst_l)
                return (size + src_l);
        i = dst_l;
        while (i + 1 < size && src[j] != '\0')
                dst[i++] = src[j++];
        dst[i] = '\0';
        return (dst_l + src_l);
}

• 입력받은 dst에 src를 size만큼 붙여 넣는다.
• 만약 size가 dst의 길이보다 작을 시 size에 src의 길이를 더해서 return 한다.
• retrun 값은 man strlcat에 따르면 dst길이 + src의 길이를 말한다.

man strlcat - return values
The strlcpy() and strlcat() functions return the total length of the stringthey tried to create.
For strlcat() that means the initial length of dst plus the length of src. While this may seem somewhat confusing, it was done to make truncation detection simple.

strchr

char    *ft_strchr(const char *s, int c)
{
        char    *ps;

        ps = (char *)s;
        while (*ps != '\0')
        {
                if (*ps == (char)c)
                        return (ps);
                ps++;
        }
        if (*ps == (char)c)
                return (ps);
        return (0);
}

• 입력받은 *s스트링에서 c를 찾아 포인터를 반환 한다.
• 입력받을 때 const char형식으로 입력받아 ps에 s포인터를 붙여넣어 c와 같은 값을 찾았다.

strrchr

char    *ft_strrchr(const char *s, int c)
{
        int             i;
        int             j;
        char    *ps;

        i = 0;
        j = -1;
        ps = (char *)s;
        while (ps[i] != '\0')
        {
                if (ps[i] == (char)c)
                        j = i;
                i++;
        }
        if (j != -1)
                return (ps + j);
        else if (ps[i] == (char)c)
                return (ps + i);
        return (0);
}

• 입력받은 *s스트링에서 c를 찾는데 마지막에 나오는 c의 포인터를 반환 한다.
• j에 c를 찾을 때마다 인덱스 i를 넣어 return할 때 ps의 포인터를 j만큼 움직여서 리턴하였다.

strncmp

int     ft_strncmp(const char *s1, const char *s2, size_t n)
{
        unsigned char   *ps1;
        unsigned char   *ps2;
        size_t                  i;	

        i = 0;
        ps1 = (unsigned char *)s1;
        ps2 = (unsigned char *)s2;
        if (n == 0)
                return (0);
        while (i < n)
        {
                if (ps1[i] != ps2[i] || ps1[i] == '\0' || ps2[i] == '\0')
                        return (ps1[i] - ps2[i]);
                i++;
        }
        return (0);
}

• s1과 s2를 n개만큼 비교하여 차이 값을 return 한다.
• n개만큼 비교해서 값이 모두 같을 시 0을 return하게 된다.

strnstr

char    *ft_strnstr(const char *big, const char *little, size_t len)
{
        size_t  i;
        size_t  j;

        i = 0;
        if ((!big || !little) && len == 0)
                return (NULL);
        if (little[i] == '\0')
                return ((char *)big);
        while (i < len && big[i])
        {
                j = 0;
                while ((i + j < len) && (big[i + j] == little[j])
                        && (little[j] != '\0'))
                        j++;
                if (little[j] == '\0')
                        return ((char *)&big[i]);
                i++;
        }
        return (NULL);
}

• big 스트링에 len 범위 에서 little문자열이 있는지 찾는 함수다.
• 인덱스 i로 big과 little의 같은 시작점을 찾고 l + j < len 범위 안에서 j인덱스로 little과 big이 일치하는지 검사한다.
• big안에 little이 있으면 little의 시작점이 있는 big의 포인터를 반환한다.
• big안에 little이 없으면 NULL포인터를 리턴한다.

atoi

ft_strtrim.c: OK!
hakslee@c2r15s1 ~/42cursus/Libft
%

int     ft_atoi(const char *str)
{
        unsigned int    result;
        int                             i;
        int                             flag;

        i = 0;
        flag = 0;
        result = 0;
        while (str[i] == ' ' || (str[i] >= 9 && str[i] <= 13))
                i++;
        if (str[i] == '-')
        {
                flag = 1;
                i++;
        }
        else if (str[i] == '+')
                i++;
        while (str[i] >= '0' && str[i] <= '9')
        {
                result = result * 10 + (str[i] - '0');
                i++;
        }
        if (flag)
                return (result * -1);
        return (result);
}

• 스트링으로 들어오는 숫자를 int로 바꾸는 함수이다.
• while space 는 i++로 인덱스를 넘긴다.
• -음수 부호를 발견하면 flag를 1로 바꾸고 i++하여 넘어간다.
  +부호는 flag를 변경하지 않는다.
• ascii코드로 0~9범위에 있으면 result에 10을 곱해 자리수를 올려주면서 1의자리에 -'0'을 넣어준다.
• flag가 1이면 -1을 곱하여 값을 음수 처리하여 retrun 한다.

mem_functions

memset

void    *ft_memset(void *s, int c, size_t n)
{
        unsigned char   *ps;
        size_t                  i;

        ps = (unsigned char *)s;
        i = 0;
        while (i < n)
        {
                ps[i] = (unsigned char)c;
                i++;
        }
        return (ps);
}

• *s를 첫 주소로 n개만큼의 메모리를 c로 초기화 시킨다.
• 메모리를 초기화 하는 작업으로 1바이트씩 c를 넣기위해 void *s -> unsigned char *ps로 포인터를 형변환하여 저장해서 작성했다.

bzero

void    ft_bzero(void *s, size_t n)
{
        unsigned char   *ps;
        size_t                  i;

        ps = (unsigned char *)s;
        i = 0;
        while (i < n)
        {
                ps[i] = 0;
                i++;
        }
        return ;
}

• *s 첫 주소로부터 n개 만큼 0으로 초기화 한다.
• 메모리를 초기화 하는 작업으로 1바이트씩 c를 넣기위해 void *s -> unsigned char *ps로 포인터를 형변환하여 저장해서 작성했다.

memcpy

void    *ft_memcpy(void *dest, const void *src, size_t n)
{
        unsigned char   *d;
        unsigned char   *s;
        size_t                  i;

        d = (unsigned char *)dest;
        s = (unsigned char *)src;
        i = 0;
        if (d == s)
                return (d);
        while (i < n)
        {
                d[i] = s[i];
                i++;
        }
        return (dest);
}

• src에 있는 메모리를 dest에 n만큼 복사하는 함수 구현이다.
• 메모리를 1바이트씩 복사하기위해 d, s로 unsigned char로 타입을 변경하여 저장하여 붙여 넣었다.

memmove

void    *ft_memmove(void *dest, const void *src, size_t n)
{
        unsigned char   *d;
        unsigned char   *s;
        size_t                  i;

        d = (unsigned char *)dest;
        s = (unsigned char *)src;
        i = 0;
        if (d == s)
                return (d);
        if (d < s)
        {
                while (i++ < n)
                        d[i - 1] = s[i - 1];
        }
        else
        {
                i = n;
                while (i-- > 0)
                        d[i] = s[i];
        }
        return (dest);
}

• 메모리를 이동하는 함수인데 memcpy보다 안정성이 더 나은 복사하는 함수라고 생각하면 된다.
• dest, src를 unsigned char 타입으로 각각 캐스팅하여 d, s로 저장했다.
• 복사 할 때 src의 메모리 주소가 dest의 주소보다 앞에 있으면 복사하다가 src메모리 영역에 dest가 있어 덮어 씌워질 수 있어 뒤에서부터 복사를 해야한다.
• if (d < s)에서 s가 d보다 뒤에 있는 경우를 확인하면 앞에서부터 순서대로 복사, 아닐 경우 i = n으로 넣어 뒤에서부터 i--하면서 복사하게 작성했다.

memchr

void    *ft_memchr(const void *s, int c, size_t n)
{
        unsigned char   *ps;
        size_t                  i;

        ps = (unsigned char *)s;
        i = 0;
        while (i < n)
        {
                if (ps[i] == (unsigned char)c)
                        return (ps + i);
                i++;
        }
        return (0);
}

• *s의 배열 중 n개의 범위 안에 c가 있는지 확인하여 만약 발견하면 c와 동일한 위치의 포인터를 반환한다.
• 동일한 것이 없을 시 return 0 한다.

memcmp

int     ft_memcmp(const void *s1, const void *s2, size_t n)
{
        unsigned char   *ps1;
        unsigned char   *ps2;
        size_t                  i;

        i = 0;
        ps1 = (unsigned char *)s1;
        ps2 = (unsigned char *)s2;
        if (n == 0)
                return (0);
        while (i + 1 < n && (ps1[i] == ps2[i]))
                i++;
        return (ps1[i] - ps2[i]);
}

• s1과 s2가 n개의 사이즈까지 비교 했을 때 동일한 문자열인지 비교하여 차이 값을 return 한다.