Libft

void *memset(void *b, int c, size_t len);

// 문자열 void *ft_memset(void *b, int c, size_t len) { // 'void *' type b를 unsigned char로 형 변환 하기 위해 arr 생성 unsigned char *arr; // 'int' type c를 unsigned char로 형 변환 하기 위해 src 생성 unsigned char src; // len과 비교하기 위해 'size_t' 형태 i 생성 size_t i; // b를 'unsigned char *'로 형 변환 arr = b; // c를 'unsigned char'로 형 변환 src = c; // len bytes를 검증하기 위해 i를 증가시키면서 len과 비교 i = 0; while (i < len) { // 형 변환 된 c를 arr에 바인딩 *arr = src; // arr 주소 값 증가 arr++; // 동시에 i도 증가 i++; } // 고쳐진 b를 리턴 return (b); }

void *memcpy(void *restrict dst, const void *restrict src, size_t n);

#include "libft.h" // 함수 원형 void *ft_memcpy(void *dst, const void *src, size_t n) { // dst와 src의 형 변환. void -> unsigned char unsigned char *new_dst; unsigned char *new_src; // byte 길이인 n과 비교하기 위한 i size_t i; // dst와 src가 완벽하게 똑같지 않거나 사이즈가 0보다 크면 수행 if (dst != src && n) { // i 초기화 i = 0; // dst 복사 new_dst = (unsigned char *)dst; // src 복사 new_src = (unsigned char *)src; // i가 n (bytes)보다 작을 때 까지 반복 while (i < n) { // new_src의 값을 new_dst로 복사 *new_dst = *new_src; // 주소 값 증가 new_dst++; new_src++; // index 증가 i++; } } // dst의 원본 리턴 return (dst); }

void *memmove(void *dst, const void *src, size_t len);

#include "libft.h" void *ft_memmove(void *dst, const void *src, size_t len) { // dst 형 변환 틀 unsigned char *new_dst; // src 형 변환 틀 unsigned char *new_src; // dst와 src가 똑같지 않고 len이 0보다 클 때 수행 if (dst != src && len) { // dst 주소 값이 src의 주소 값보다 작을 때 // 기존 memcpy와 유사한 방식으로 옮긴다 if (dst < src) { new_dst = (unsigned char *)dst; new_src = (unsigned char *)src; while (len--) *new_dst++ = *new_src++; } // dst 주소 값이 src의 주소 값보다 크거나 같을 때 // 뒤에서 부터 하나씩 옮긴다. else { new_dst = (unsigned char *)dst + (len - 1); new_src = (unsigned char *)src + (len - 1); while (len--) *new_dst-- = *new_src--; } } return (dst); }

size_t strlcpy(char *restrict dst, const char *restrict src, size_t dstsize);

#include "libft.h" size_t ft_strlcpy(char *dst, const char *src, size_t dstsize) { // dstsize와 비교할 값인 idx size_t idx; idx = 0; // 만약 복사의 대상인 src가 없으면 0을 리턴 src의 길이가 0이기 때문 if (!src) return (0); // 복사할 길이가 0이 아니면 수행 if (dstsize != 0) { // idx가 dstsize - 1일 때까지, 원본 값이 null이 아닐 때까지 수행 while (idx < dstsize - 1 && src[idx]) { // 복사, idx 증가 dst[idx] = src[idx]; idx++; } // 복사가 된 dst의 마지막에 null문자를 집어넣어 마무리 dst[idx] = '\0'; } // src의 길이 리턴 return (ft_strlen(src)); }

size_t strlcat(char * restrict dst, const char * restrict src, size_t dstsize);

#include "libft.h" size_t ft_strlcat(char *dst, const char *src, size_t dstsize) { // dst에 종속되는 index size_t i; // src에 종속되는 index size_t j; // dst와 src의 길이 size_t len_dst; size_t len_src; i = 0; j = 0; len_dst = ft_strlen(dst); len_src = ft_strlen(src); // 만약 dstsize가 dst의 길이보다 작으면, src의 길이와 dst_size를 더해 리턴 if (dstsize < len_dst) return (len_src + dstsize); // dst의 끝을 찾아 떠나는 여행 while (dst[i]) i++; // src와 i가 dstsize - 1일때 수행 (마지막에 NULL이 들어가야 하기 위해서.) while (src[j] && i < dstsize - 1) { dst[i] = src[j]; i++; j++; } // 마지막에 NULL 문자 넣기 dst[i] = '\0'; // return the total length of the string tried to create. return (len_dst + len_src); }

char *strchr(const char *s, int c);

#include "libft.h" char *ft_strchr(const char *s, int c) { // 문자열을 순회하며 c와 일치하는지 여부 탐색 while (*s) { // 문자 s와 c가 같으면 if (*s == c) // s의 주소 값을 형 변환하여 리턴 return ((char *)s); // 찾을 때 까지 주소 증가 s++; } // 만약 s가 0(NULL)이고, s와 c가 같다면. (s와 c 모두 NULL) if (*s == 0 && *s == c) // NULL이 위치한 주소 리턴 return ((char *)s); // 못 찾으면 NULL 리턴 return (0); }

char *strrchr(const char *s, int c);

#include "libft.h" char *ft_strrchr(const char *s, int c) { // 문자열 s의 길이가 될 idx int idx; // s의 길이 바인딩 idx = ft_strlen(s); // idx가 0이 될 때 까지. 다시 말해 s[0]까지 수행 while (idx >= 0) { // 만약 c를 만나게 되면 리턴 if (s[idx] == (char)c) // 문자열을 뒤에서부터 순회하기 때문에 s 주소 값에 idx를 더한 주소 값을 리턴 return ((char *)s + idx); idx--; } return (NULL); }

int strncmp(const char *s1, const char *s2, size_t n);

void *memchr(const void *s, int c, size_t n)

int memcmp(const void *s1, const void *s2, size_t n);

char *strnstr(const char *haystack, const char *needle, size_t len);

#include "libft.h" char *ft_strnstr(const char *haystack, const char *needle, size_t len) { // len과 비교 될 needle의 길이 t_len size_t t_len; // 만약 needle이 빈 문자열이라면 haystack의 주소 값을 반환 if (*needle == '\0') return ((char *)haystack); // 찾는 문자열(needle)의 길이를 t_len에 바인딩 t_len = ft_strlen(needle); // haystack이 null이 아니고 len이 t_len보다 같거나 클 때 까지 반복 while (*haystack && (len-- >= t_len)) { // 만약 haystack의 '문자'와 needle의 '문자'와 같다면 if (*haystack == *needle) { // 그 곳 부터 needle의 길이만큼 메모리를 비교한다. // 만약 결과가 0이면 needle이 온전히 haystack 안에 들어있다는 뜻이기 때문에 // haystack의 주소를 반환한다. if (ft_memcmp(haystack, needle, t_len) == 0) return ((char *)haystack); } haystack++; } // 못 찾으면 NULL 리턴 return (0); }

int atoi(const char *str);

#include "libft.h" // 공백 판별 static int ft_isspace(char c) { if ((c >= '\t' && c <= '\r') || c == ' ') return (1); return (0); } // 부호 판별 static int ft_issign(char c) { if (c == '+' || c == '-') return (1); return (0); } // 수 판별 static int ft_isnum(char c) { if (c >= '0' && c <= '9') return (1); return (0); } int ft_atoi(const char *str) { // 부호 int sign; // 부호 수 int cnt_sign; // 결과 long long result; // sign : 1 or -1 sign = 1; // 부호 수 cnt_sign = 0; result = 0; // 공백 부분 스킵 while (ft_isspace(*str)) str++; // 부호 부분 스킵 while (ft_issign(*str)) { // 만약 str 문자가 '-'라면 sign에 -1 곱해줌 if (*str == '-') sign *= -1; // 주소 값 증가 str++; // 부호 수 증가 cnt_sign++; // 만약 부호 수가 1보다 크다면 0 리턴 if (cnt_sign > 1) return (0); } // 숫자를 판별하여 숫자면 계속 진행 while (ft_isnum(*str)) { // result에 있는 값에 10을 곱하고 str문자를 수로 바꾸어 더해줌 result = (result * 10) + (*str - '0'); str++; } // result와 부호를 곱해서 반환 return ((int)result * sign); }

void *calloc(size_t count, size_t size);

#include "libft.h" void *ft_calloc(size_t count, size_t size) { // void형의 빈 포인터 객체 생성 void *buf; // malloc으로 메모리 할당 buf = (void *)malloc(count * size); // 만약 제대로 할당이 되지 않아 오류가 발생했다면 NULL을 반환한다 if (!buf) return (NULL); // 할당이 성공했다면, 각 메모리를 0으로 채우고 반환한다. ft_bzero(buf, count * size); return (buf); }

char *strdup(const char *s1);

#include "libft.h" char *ft_strdup(const char *s1) { // char type의 객체 생성 char *buf; int idx; idx = 0; // malloc으로 s1의 길이 + null의 길이 만큼 메모리를 할당 buf = (char *)malloc((ft_strlen(s1) + 1) * sizeof(char)); // 할당 오류 시 NULL 반환 if (!buf) return (NULL); // s1이 NULL일 때 까지 반복하며 buf[idx]에 s1[idx]를 할당 while (s1[idx]) { buf[idx] = s1[idx]; idx++; } // 마지막 공간에 NULL 문자를 넣은 후 buf의 주소를 반환 buf[idx] = '\0'; return (buf); }

char *ft_substr(char const *s, unsigned int start, size_t len);

char *ft_strjoin(char const *s1, char const *s2);

#include "libft.h" char *ft_strjoin(char const *s1, char const *s2) { // s1과 s2를 합치는 새로운 문자열 char *buf; // s1과 s2의 길이 size_t len_s1; size_t len_s2; // 만약 두 문자열 중 하나라도 빈 문자열이면 NULL 반환 if (!s1 || !s2) return (NULL); // s1과 s2의 길이 바인딩 len_s1 = ft_strlen(s1); len_s2 = ft_strlen(s2); // s1과 s2의 길이 그리고 NULL문자의 길이를 포함하여 buf에 메모리 할당 buf = (char *)malloc((len_s1 + len_s2 + 1) * sizeof(char)); // 만약 buf 할당이 실패하면 NULL 리턴 if (!buf) return (NULL); // strlcpy를 활용해 s1을 할당 ft_strlcpy(buf, s1, len_s1 + 1); // strlcpy를 활용해 s2을 할당 ft_strlcpy(buf + len_s1, s2, len_s2 + 1); return (buf); }

char **ft_split(char const *s, char c);

#include "libft.h" // 단어의 개수를 반환하는 함수 static int ft_count(char const *s, char c) { int cnt; cnt = 0; while (*s) { if (*s == c) cnt++; s++; } return (cnt + 1); } // 할당 된 배열을 free 해주는 함수이다 static char **ft_free_garb(char **a) { int i; i = 0; while (a[i]) { free(a[i]); i++; } free(a); return (NULL); } // 문자열 s를 c로 나누기 char **ft_split(char const *s, char c) { // 나누어진 단어를 담을 tmp char *tmp; // 마지막에 리턴이 될 모든 단어를 담은 tab char **tab; int i; i = 0; // ft_count -> c를 기준으로 단어의 개수를 반환 // 단어의 개수 + 1(NULL)만큼 tab에 할당 tab = (char **)malloc((ft_count(s, c) + 1) * sizeof(char *)); // 만약 할당이 실패했거나 s가 NULL이라면 NULL 반환 if (!tab || !s) return (NULL); // s를 순회하면서 수행 while (*s) { // 만약 s의 문자와 c가 다르다면 단어에 속하는것으로 if (*s != c) { // tmp에 현재 s의 주소를 저장하고 tmp = (char *)s; // s가 c가 아닐 때까지 주소를 증가시킨다 while (*s && *s != c) s++; // ft_substr을 사용하여 tmp의 첫 번째 주소부터 찾아낸 길이까지 tab[i]에 할당 tab[i] = ft_substr(tmp, 0, (s - tmp)); // 만약 제대로 할당이 되지 않았다면 free if (!tab[i]) return (ft_free_garb(tab)); i++; } // s와 c가 같다면 주소 증가 else s++; } // 마지막에 NULL tab[i] = NULL; return (tab); }

char *ft_itoa(int n);

char *ft_strtrim(char const *s1, char const *set);

char *ft_strmapi(char const *s, char (*f)(unsigned int, char));