42cursus 과정의 첫 과제인 Libft의 Part 1 부분을 정리하고자 한다.
1. ft_memset
void *ft_memset(void *b, int c, size_t len)
{
unsigned char *new_b;
unsigned char src;
size_t i;
new_b = (unsigned char *)b;
src = (unsigned char)c;
i = 0;
while (i < len)
{
*new_b++ = src;
i++;
}
return (b);
}memset 함수는 어떤 메모리의 시작점부터 연속된 범위를 어떤 값으로(바이트 단위) 모두 지정하고 싶을 때 사용하는 함수이다.
- 초기화 하고자 하는 값은 int 값으로 들어오게 되는데 이 때 unsigned char 형으로 형변환 시켜준 후 진행해야 한다.
메모리 접근 시 unsigned char로 접근해야 하는 이유 - 메모리를 unsigned char를 통해 1바이트 씩 초기화 함을 주의하자.
2. ft_bzero
void ft_bzero(void *s, size_t n)
{
unsigned char *dst;
size_t i;
dst = (unsigned char *)s;
i = 0;
while (i < n)
{
*dst++ = 0;
i++;
}
}memset과 유사하게 메모리의 시작점부터 연속된 범위를 0으로 초기화하는 함수이다.
- 비표준 함수 이기 때문에 memset을 사용하기를 추천한다.
3. ft_memcpy
void *ft_memcpy(void *dst, const void *src, size_t n)
{
unsigned char *new_dst;
unsigned char *new_src;
size_t i;
if (!dst && !src)
return (0);
new_dst = (unsigned char *)dst;
new_src = (unsigned char *)src;
i = 0;
while (i < n)
{
*new_dst++ = *new_src++;
i++;
}
return (dst);
}src가 가르키는 memory 부터 n 바이트 만큼 dst가 가르키는 메모리에 복사하는 함수이다.
- null 문자를 검사하지 않고 n 바이트 만큼 무조건 적으로 복사하게 된다.
- overlap 문제가 발생할 수 있기 때문에 memmove 함수를 사용하는 것을 추천한다.
memcpy vs memmove
4. ft_memccpy
void *ft_memccpy(void *dst, const void *src, int c, size_t n)
{
unsigned char *new_dst;
unsigned char *new_src;
unsigned char find;
size_t i;
new_dst = (unsigned char *)dst;
new_src = (unsigned char *)src;
find = (unsigned char)c;
i = 0;
while (i < n)
{
*new_dst = *new_src;
if (*new_src == find)
return (dst + (i + 1));
new_dst++;
new_src++;
i++;
}
return (0);
}src 데이터에서 n바이트의 데이터를 dest에 복제할 때에 src 데이터에서 문자 c를 만나면 c까지 복제하고 복제를 중단합니다.
복제된 dest변수에서 복제가 끝난 다음 번지를 return합니다.
만약 문자 c를 만나지 않았다면, n바이트를 복제하고 NULL을 return하는 함수이다.
5. ft_memmove
void *ft_memmove(void *dst, const void *src, size_t len)
{
unsigned char *new_dst;
unsigned char *new_src;
size_t i;
if (dst == src || len == 0)
return (dst);
new_dst = (unsigned char *)dst;
new_src = (unsigned char *)src;
i = 0;
if (dst < src)
while (i++ < len)
*new_dst++ = *new_src++;
else
{
new_dst = new_dst + len - 1;
new_src = new_src + len - 1;
while (i++ < len)
*new_dst-- = *new_src--;
}
return (dst);
}src 메모리 영역에서 dest 메모리 영역으로 n byte 만큼 복사합니다.
src 배열은 src와 dest 의 메모리 영역과 겹치지 않는 메모리 영역부터 먼저 복사하는 함수이다.
- overlap 의 해결 방안
- 뒤에서 부터 한 바이트씩 복사한다.
6. ft_memchr
void *ft_memchr(const void *s, int c, size_t n)
{
size_t i;
i = 0;
while (i++ < n)
{
if (*(unsigned char *)s == (unsigned char)c)
return ((void *)s);
s++;
}
return (0);
}s가 가르키는 memory에서 n 바이트 중 c가 나타내는 문자를 찾아 주소를 반환하는 함수이다.
7. ft_memcmp
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
size_t i;
i = 0;
while (i++ < n)
{
if (*(unsigned char *)s1 != *(unsigned char *)s2)
return (*(unsigned char *)s1 - *(unsigned char *)s2);
s1++;
s2++;
}
return (0);
}s1이 가르키는 주소에서 n 바이트의 데이터와 s2가 가르키는 주소에서 n 바이트의 데이터를 비교하여 같으면 0을 반환하는 함수이다.
- 오버플로우 처리가 가능한가 ?
memcmp overflow
무조건 n 바이트만큼 비교하기 때문에 널문자를 지나 쓰레기 값끼리 비교할 수도 있는 문제점
n 바이트의 크기에 주의하자.
8. ft_strlen
size_t ft_strlen(const char *s)
{
size_t len;
len = 0;
while (s[len])
len++;
return (len);
}문자열 s를 인자로 받아 길이를 반환해 주는 함수
9. ft_strlcpy
size_t ft_strlcpy(char *dst, const char *src, size_t dstsize)
{
size_t src_len;
size_t i;
if (dst == 0 || src == 0)
return (0);
src_len = ft_strlen(src);
i = 0;
if (dstsize > 0)
{
while (src[i] != '\0' && i < dstsize - 1)
{
dst[i] = src[i];
i++;
}
dst[i] = '\0';
}
return (src_len);
}10. ft_strlcat
size_t ft_strlcat(char *dst, const char *src, size_t dstsize)
{
size_t dst_len;
size_t src_len;
size_t i;
size_t dst_len_tmp;
dst_len = 0;
src_len = ft_strlen(src);
if (dstsize == 0)
return (src_len);
while (dst[dst_len] != '\0' && dst_len < dstsize)
dst_len++;
dst_len_tmp = dst_len;
i = 0;
if (dst_len < dstsize)
{
while (dst_len < (dstsize - 1) && src[i])
dst[dst_len++] = src[i++];
dst[dst_len] = '\0';
}
if (dstsize < dst_len_tmp)
return (dstsize + src_len);
return (dst_len_tmp + src_len);
}11. ft_strchr
char *ft_strchr(const char *s, int c)
{
while (*s && *s != c)
s++;
if (*s == (char)c)
return ((char *)s);
return (0);
}12. ft_strrchr
char *ft_strrchr(const char *s, int c)
{
char *str;
str = NULL;
while (*s != '\0')
{
if (*s == (char)c)
str = (char *)s;
s++;
}
if ((char)c == '\0')
return ((char *)s);
return (str);
}13. ft_strnstr
char *ft_strnstr(const char *haystack, const char *needle, size_t len)
{
size_t i;
size_t j;
i = 0;
if (*needle == '\0')
return ((char *)haystack);
while (haystack[i] && i < len)
{
if (haystack[i] == needle[0])
{
j = 1;
while (needle[j] && haystack[i + j] == needle[j] && i + j < len)
j++;
if (needle[j] == '\0')
return ((char *)haystack + i);
}
i++;
}
return (0);
}14. ft_strncmp
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
size_t i;
if (n == 0)
return (0);
i = 0;
while (i < n - 1 && s1[i] == s2[i] && s1[i] != '\0' && s2[i] != '\0')
i++;
return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}15. ft_atoi
int ft_atoi(const char *str)
{
long long int res;
long long int sign;
res = 0;
sign = 1;
while (*str && (*str == ' ' || (*str >= 9 && *str <= 13)))
str++;
if (*str == '-' || *str == '+')
{
if (*str == '-')
sign = sign * -1;
str++;
}
while (*str >= '0' && *str <= '9')
{
res = res * 10 + *str - '0';
if (res > 2147483647 && sign == 1)
return (-1);
if (res > 2147483648 && sign == -1)
return (0);
str++;
}
return (sign * res);
}16. ft_isalpha
int ft_isalpha(int c)
{
return ((c >= 65 && c <= 90) || (c >= 97 && c <= 122));
}17. ft_isdigit
int ft_isdigit(int c)
{
return (c >= '0' && c <= '9');
}18. ft_isalnum
int ft_isalnum(int c)
{
return (ft_isalpha(c) || ft_isdigit(c));
}19. ft_isascii
int ft_isascii(int c)
{
return (c >= 0 && c <= 127);
}20. ft_isprint
int ft_isprint(int c)
{
return (c >= 32 && c <= 126);
}21. ft_toupper
int ft_toupper(int c)
{
if (c >= 97 && c <= 122)
c = c - 32;
return (c);
}22. ft_tolower
int ft_tolower(int c)
{
if (c >= 65 && c <= 90)
c = c + 32;
return (c);
}23. ft_calloc
void *ft_calloc(size_t count, size_t size)
{
void *memory;
if (!(memory = malloc(count * size)))
return (0);
ft_bzero(memory, count * size);
return (memory);
}24. ft_strdup
char *ft_strdup(const char *s1)
{
size_t len;
size_t i;
char *str;
len = ft_strlen(s1);
if (!(str = (char *)malloc(sizeof(char) * (len + 1))))
return (0);
i = 0;
while (i < len)
{
str[i] = s1[i];
i++;
}
str[i] = '\0';
return (str);
}
42Seoul Cadet
너무 좋아용