목차
Libft
part 1 - Libc functions
isalpha • isdigit • isalnum • isascii • isprint • strlen • memset • bzero • memcpy • memmove • strlcpy • strlcat • toupper • tolower • strchr • strrchr • strncmp • memchr • memcmp • strnstr • atoi • calloc • strdup
part 2 - Additional functions
ft_substr
ft_strjoin
ft_strtrim
ft_split
ft_itoa
ft_strmapi
ft_striteri
ft_putchar_fd
ft_putstr_fd
ft_putendl_fd
ft_putnbr_fd
Libft
42 Seoul에서 진행한 나만의 라이브러리 만들기 과제입니다. low-level로 직접 기본 함수들을 구현합니다. part 1, 2로 이루어져 있습니다.
part 1 - Libc functions
isalpha
해당 매개변수 값이 알파벳 소/대문자임을 확인하는 함수입니다.
매개변수로 들어온 int 자료형 c 값을 ascii상에서 소문자 대문자에 따라서 return 값을 달리한다.
int ft_isalpha(int c)
{
if (c >= 65 && c <= 90)
return (1);
else if (c >= 97 && c <= 122)
return (2);
else
return (0);
}isdigit
해당 매개변수 값이 숫자인지 확인하는 함수입니다.
매개변수로 들어온 int 자료형 c 값을 ascii 코드 상에서 숫자가 맞으면 4를 리턴하고 나머지는 0을 리턴한다.
int ft_isdigit(int c)
{
if (c >= 48 && c <= 57)
return (4);
else
return (0);
}isalnum
해당 매개변수 값이 수이거나 소/대문자임을 확인하는 함수입니다.
매개변수 값이 ascii 코드 상에서 수 또는 소/대문자가 맞으면 1을 리턴하며 나머지는 0을 리턴합니다.
int ft_isalnum(int ch)
{
if (ch >= 48 && ch <= 57)
return (1);
else if (ch >= 65 && ch <= 90)
return (1);
else if (ch >= 97 && ch <= 122)
return (1);
else
return (0);
}isascii
해당 매개변수 값이 ascii 코드 상에 존재하는 값인지 확인하는 함수입니다.
매개변수 값이ascii 코드 상에서 존재하는 0~127 값이면 1을 리턴, 나머지는 0을 리턴합니다.
int ft_isascii(int c)
{
if (c >= 0 && c <= 127)
return (1);
else
return (0);
}isprint
해당 매개변수 값이 ascii 코드 상에서 출력가능한 값인지 확인하는 함수입니다.
매개변수 값이 ascii 코드 상에서 출력가능한 범위(32 ~ 126) 면 1을 리턴, 나머지는 0을 리턴합니다.
int ft_isprint(int ch)
{
if (ch >= 32 && ch <= 126)
return (1);
else
return (0);
}
strlen
매개변수로 들어온 포인터가 가리키는 string 길이를 재는 함수입니다.
int tmp; 로 길이를 재기 위한 임시 인덱스 값 설정 후 해당 포인터 값을 증가시키며, 포인터도 이동시키며 tmp 길이도 같이 늘립니다. 그리고 tmp 값을 리턴합니다.
#include "libft.h"
size_t ft_strlen(const char *str)
{
int tmp;
tmp = 0;
while (*str)
{
tmp++;
str++;
}
return (tmp);
}memset
memset 함수는 해당 매개변수 값을 value 로 num 수만큼 초기화시킵니다. mem, setting
매개변수로 할당한 ptr이 가리키는 자료형의 값을 value 값으로 num 수만큼 채웁니다. void 값으로 들어오기 때문에 unsigned char 값으로 캐스팅합니다. 포인터로 가리켜 값을 할당하기 위해서입니다.
해당 메모리 값으로 채우고 리턴합니다.
#include "libft.h"
void *ft_memset(void *ptr, int value, unsigned int num)
{
unsigned char data;
unsigned char *start_ptr;
start_ptr = (unsigned char *)ptr;
data = (unsigned char)value;
while (num-- > 0)
*start_ptr++ = data;
return (ptr);
}
bzero
bzero 함수는 매개변수로 들어온 포인터가 가리키는 string 값을 n만큼 zero값으로 초기화시킵니다.
void 형이기 때문에 return 값이 없다. unsigned char 형으로 캐스팅한 후 해당 포인터를 가리켜 값을 초기화시킵니다.
#include "libft.h"
void ft_bzero(void *ptr, size_t n)
{
unsigned char *dest;
unsigned int i;
dest = (unsigned char *)ptr;
i = 0;
while (i < n)
{
*dest = 0;
dest++;
i++;
}
}memcpy
memcpy 함수는 매개변수로 들어온 포인터가 가리키는 dest에 src값을 cnt 만큼 복사합니다.
매개변수로 들어오는 값이 빈 값이 아닌지 검사 후 빈 값이면 dest를 리턴합니다. 그리고 dest는 char 포인터에 할당하고 src는 s로 할당 후, cnt 만큼 붙여 넣어줍니다. 마지막으로 dest값으로 리턴합니다.
#include "libft.h"
void *ft_memcpy(void *dest, const void *src, size_t cnt)
{
char *tmp;
const char *s;
if (!dest && !src)
return (dest);
tmp = dest;
s = src;
while (cnt--)
*tmp++ = *s++;
return (dest);
}
memmove
memmove 함수는 src 포인터가 가리키는 문자열을 dest 포인터가 가르키는 문자열로 n만큼 값을 이동시키는 함수입니다.
dest, src 가 빈 값인지 확인 후 빈 값이면 Null 값을 리턴합니다. 함수 내부에서는 dest, src을 가리키기 위한 pointer, p_dest, p_src을 할당합니다. (캐스팅하여 포인터를 가리키게 합니다) 그 후는, dest와 src 값의 위치를 판단하여 어떤 곳부터 이동시킬지 분기를 정합니다.
if문을 보게 되면 dest < src 일 경우는 앞부터 차례대로, 이동시킵니다. 하지만 반대일 경우는 뒤부터 이동시킵니다. dest > src 일 경우에 앞 부터 넣게 되면 값 자체가 이동되지 않는 경우가 생깁니다. 그렇기에 else 문 안처럼, 포인터를 Null 값을 제외한 (n-1) 값을 더한 후 뒤부터 움직입니다.
이해를 위한 블로그 링크입니다.
https://hand-over.tistory.com/47
memmove 사용법 및 구현 - C 메모리 이동
사용법 #include void *memmove(void *dest, const void *src, size_t n); 정의 memmove() 함수는 src 메모리 영역에서 dest 메모리 영역으로 n byte 만큼 복사합니다. src 배열은 src와 dest 의 메모리 영역과 겹..
hand-over.tistory.com
마지막으로는 모두 이동된 dest를 리턴합니다.
#include "libft.h"
void *ft_memmove(void *dest, const void *src, size_t n)
{
unsigned char *p_dest;
unsigned char *p_src;
if (dest == 0 && src == 0)
return (0);
p_dest = (unsigned char *)dest;
p_src = (unsigned char *)src;
if (dest < src)
{
while (n--)
*p_dest++ = *p_src++;
}
else
{
p_dest = dest + (n - 1);
p_src = (unsigned char *)src + (n - 1);
while (n--)
*p_dest-- = *p_src--;
}
return (dest);
}
strlcpy
strlcpy 함수는 strcpy 함수처럼 copy의 기능을 하지만, 동시에 length값을 리턴합니다.
size 가 0일 경우에 곧바로 src의 길이를 리턴합니다.(copy 할 size가 할당되지 않았음)
while 문 안의 조건을 보면, size를 넘지 않을 만큼 인덱스 조건을 설정하였고 동시에 src 인덱스 조건도 확인합니다.
while 문을 다 돌고 나서(복사가 된 상태)도 size값이 남았다면(위에 src + i 조건으로 통과) 마지막 인덱스를 닫아줍니다.
마지막으로는 length 기능인, src길이를 리턴해줍니다.
#include "libft.h"
size_t ft_strlcpy(char *dest, const char *src, size_t size)
{
size_t i;
i = 0;
if (size == 0)
return (ft_strlen(src));
while ((i + 1) < size && *(src + i))
{
*(dest + i) = *(src + i);
i++;
}
if (size > 0)
*(dest + i) = 0;
return (ft_strlen(src));
}strlcat
strlcat 함수는 string을 연결하면서 동시에 length을 반환하는 함수입니다.
dest 포인터가 가리키는 문자열 뒤에 src 포인터가 가르키는 문자열을 len만큼 붙입니다. dest_len, src_len 값을 ft_strlen 함수를 사용하여 가져옵니다.
if 문 안을 보면, len 값 보다 dest_len 값이 작거나 같으면 src_len + len 값을 리턴합니다. len 값이 너무 작기에 붙일 수 없습니다. 그렇기 때문에 붙이는 과정이 사라지며 length값을 리턴합니다.
while 문 조건을 보면, src길이만큼 붙인다는 조건이 있으며, dest_len + i + 1 < len 조건을 보면 dest_len 이 의미하는 것은 dest 길이 이후 i 인덱스 값을 더해서 마지막에 널값까지 len에 포함된 것입니다.
마지막으로 dest문자열의 마지막 인덱스에 Null 값을 넣어줍니다. 그리고 src 길이와 dest 길이를 더 해 리턴합니다.(연결된 문자열의 길이)
#include "libft.h"
size_t ft_strlcat(char *dest, const char *src, size_t len)
{
size_t dest_len;
size_t src_len;
size_t i;
i = 0;
dest_len = ft_strlen(dest);
src_len = ft_strlen(src);
if (len <= dest_len)
return (src_len + len);
while (src[i] && dest_len + i + 1 < len)
{
dest[dest_len + i] = src[i];
i++;
}
dest[dest_len + i] = '\0';
return (src_len + dest_len);
}toupper
toupper 함수는 매개변수로 들어온 값이 소문자인지 확인 후 대문자로 변환하는 함수입니다.
int ft_toupper(int c)
{
if (c >= 97 && c <= 122)
return (c -= 32);
else
return (c);
}tolower
tolower 함수는 매개변수로 들어온 값이 대문자인지 확인 후 소문자로 변환하는 함수입니다.
int ft_tolower(int ch)
{
if ((ch >= 'A') && (ch <= 'Z'))
ch += 32;
return (ch);
}
strchr
strchr 함수는 매개변수로 들어온 포인터가 가리키는 문자열에서 매개변수로 들어온 int 자료형 c 문자를 찾은 곳부터 문자열을 리턴하는 함수입니다.
포인터를 설정하고, 그 포인터에 들어온 매개변수 포인터를 캐스팅해 값을 설정해줍니다. 그리고 while 문을 사용하여 문자열 중에 해당 문자가 있는지 찾습니다. if문을 보면 해당 값을 찾았기 때문에 그 위치의 포인터를 리턴합니다.
c 가 빈 값일 경우 ptr(현재 널, 왜냐하면 끝까지 돌기 때문에)을 리턴합니다. 마지막으로는 널을 리턴합니다.
#include "libft.h"
char *ft_strchr(char const *str, int c)
{
char *ptr;
ptr = (char *)str;
while (*ptr)
{
if (*ptr == (char)c)
return (ptr);
ptr++;
}
if (c == 0)
return (ptr);
return (0);
}
strrchr
strrchr 함수는 strchr 함수와 기능은 같지만, 뒤에서 부터 찾는 것이 다릅니다.
그렇기 때문에 ft_strlen 함수를 사용해 len 길이를 알아냅니다. ch == 0 조건이 들어간 것은 Null 값이 매개변수로 들어왔기 때문에 마지막 주소 값(Null)을 리턴합니다.
예외처리 후 len 이 0이 될 때까지 뒤에서부터 찾습니다. while 문 안의 if문은 뒤에서 부터 값을 읽어 나가며 찾는 조건입니다. str [len - 1]은 마지막 Null 값을 제외하기 위해 len - 1을 설정했습니다. 조건을 만족하면 해당 값의 주소 값을 리턴합니다.(포인터 리턴)
마지막으로 찾지 못했을 경우에는 Null 값을 리턴합니다.
#include "libft.h"
char *ft_strrchr(const char *str, int ch)
{
size_t len;
len = ft_strlen(str);
if (ch == 0)
return ((char *)&str[len]);
while (len != 0)
{
if (str[len - 1] == (unsigned char)ch)
return ((char *)&str[len - 1]);
len--;
}
return (0);
}strncmp
strncmp 함수는 n만큼 비교해서 다른 부분이 있으면 s1에서 s2 값을 뺀 값을 리턴합니다.
if문은 n이 빈 값일 경우에 Null을 리턴합니다.
while 문 안의 조건을 보면, i + 1 < n에서 i + 1 은 널 값, 끝 값까지 포함된 값이며 그 값이 n 보다 작을 경우에 비교합니다.(Null은 비교대상이 아님) (s1 [i] || s2 [i]) 조건은 둘 중 하나가 빈 값이면 인덱스를 읽지 못하게 합니다.(비교 대상이 Null이면 비교할 수 없음)
if 문 안의 조건을 보면 s1 [i]!= s2 [i]으로 조건을 설정해두었는데, 이 조건이 말하는 것은 해당 인덱스에서 다른 값을 의미하는 것입니다. 그렇다면 break 하여 최종 결과 값을 리턴합니다.
#include "libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
size_t i;
i = 0;
if (n == 0)
return (0);
while (i + 1 < n && (s1[i] || s2[i]))
{
if (s1[i] != s2[i])
break ;
i++;
}
return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}
memchr
memchr 함수는 문자열에서 설정한 길이 내만큼 문자를 찾는 함수입니다.
while 문 안의 조건을 보게 되면 nb길이만큼 돌게 되며, 그 안의 if문 조건이 만족하면 해당 위치에서 포인터를 리턴합니다.
마지막으로 찾지 못한 경우에는 Null을 리턴합니다.
#include "libft.h"
void *ft_memchr(const void *s, int ch, size_t nb)
{
unsigned char *s_ptr;
unsigned char chr;
chr = ch;
s_ptr = (unsigned char *)s;
while (nb--)
{
if (*s_ptr == chr)
return (s_ptr);
s_ptr++;
}
return (0);
}
memcmp
memcmp 함수는 두 개의 메모리 블록을 비교하는 함수입니다.
void 형으로 들어온 자료형을 char 형으로 캐스팅합니다. 그리고 size 만큼 비교합니다. 비교하면서 다른 부분이 나왔을 경우 그 부분에서 s1 - s2 값을 리턴합니다.
마지막으로 찾지 못했을 경우는 Null 값을 리턴합니다.
#include "libft.h"
int ft_memcmp(const void *str1, const void *str2, size_t size)
{
unsigned char *s1;
unsigned char *s2;
s1 = (unsigned char *)str1;
s2 = (unsigned char *)str2;
while (size-- > 0)
{
if (*s1 != *s2)
return (*s1 - *s2);
s1++;
s2++;
}
return (0);
}
strnstr
strnstr 함수는 상대적으로 긴 문자열에서 짧은 문자열을 len만큼 찾아서 리턴하는 함수입니다.
if 문 조건을 보면 짧은 문자열이 빈 값인 Null 일 경우 긴 문자열을 리턴합니다.
while 문 조건을 보면 긴 문자열이 Null 이 아니고 임의로 설정한 인덱스 값이 len 보다 작을 경우에 만족할 때까지만 짧은 문자열을 찾습니다.
while 문 안의 while 문을 보게 되면, 현재 i 인덱스 값이 긴 문자열의 위치이고 거기에 짧은 문자열을 찾기 위해 인덱스 j를 설정해줍니다. 동시에 인덱스 값도 len과 비교합니다. if 문은 현재 가리키고 있는 부분이 Null이라는 것인데, 이 의미는 짧은 길이의 문자열을 다 찾았다는 의미입니다. 그렇기 때문에 해당 위치의 i 인덱스(처음 찾은 부분)가 가리키고 있는 부분을 긴 길이의 문자열에서 리턴합니다.
마지막으로 못 찾았을 경우에 Null 값으로 리턴합니다.
#include "libft.h"
char *ft_strnstr(const char *big, const char *little, size_t len)
{
size_t i;
size_t j;
i = 0;
if (little[i] == 0)
return ((char *)big);
while (big[i] != 0 && i < len)
{
j = 0;
while (big[i + j] == little[j] && i + j < len)
{
j++;
if (little[j] == 0)
return ((char *)&big[i]);
}
i++;
}
return (0);
}
atoi
atoi 함수는 문자열을 숫자로 변환하는 함수입니다.
while 문으로 공백 문자열을 제거합니다. 그리고 if 문을 보게 되면, 부호를 걸러내어 해당 부호가 '-'일 경우에 sign에 -1을 곱해줍니다. 문자열이 음수일 경우에 마지막에 곱해주기 위해 sign을 할당했습니다.
두 번째 while 문을 보면 문자열에 문자를 읽어 해당 수에 해당하는 값을 숫자로 변환합니다.
마지막으로 모든 while 문을 통과하게 되면, 해당 값이 max값을 넘어가는지, 부호는 어떤지 확인 후, return 으로 분기를 나눠줍니다.
예외처리를 통과하면, result 값에 부호를 곱해 리턴합니다.
int ft_atoi(const char *str)
{
unsigned long long result;
unsigned long long max;
int sign;
sign = 1;
result = 0;
max = 9223372036854775807;
while ((9 <= *str && *str <= 13) || *str == ' ')
str++;
if (*str == '-' || *str == '+')
{
if (*str == '-')
sign *= -1;
str++;
}
while (*str >= '0' && *str <= '9')
{
result = (result * 10) + (*str - '0');
str++;
}
if (result > max && sign == 1)
return (-1);
else if (result > max + 1 && sign == -1)
return (0);
return (result * sign);
}
part 2 - Additional functions
ft_substr
substr 함수는 정해진 문자열을 자르는 함수입니다.
if 문을 보면 앞에서 예외처리를 해줍니다. s값이 Null인 경우 Null로 리턴해줍니다. start 값이 문자열 길이보다 길다면 빈 문자열을 리턴합니다.
또한 len 길이가 문자열 길이보다 긴 경우 sub_len에 문자열 길이를 할당해줍니다. 그렇지 않다면 반대로 len길이를 sub_len 길이로 할당합니다. 이렇게 해주는 이유는 시작하는 인덱스 값 길이와 len 길이를 조정해서 빈 값이 들어가지 않도록 설정해두기 위해서입니다.
그리고 새로운 문자열 sub를 동적 할당해줍니다. 여기서 길이는 위에서 만든 sub_len을 사용합니다.
마지막으로, while 문 안의 조건을 보면, i < len 인덱스 길이 조건, start + i < ft_strlen(s) 자르는 부분의 길이가 문자열 길이보다 작은 조건, 마지막 조건은 문자열이 끝나진 않은지, 이렇게 세 조건을 활용하였습니다.
그리고 쭉 채워주고 마지막엔 Null 값을 넣어주고 지금까지 만든 문자열 sub를 리턴해줍니다.
#include "libft.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
size_t i;
size_t sub_len;
char *sub;
if (s == 0)
return (0);
if (start >= ft_strlen(s))
return (ft_strdup(""));
if (len > ft_strlen(s))
sub_len = ft_strlen(s);
else
sub_len = len;
sub = (char *)malloc(sizeof(char) * (sub_len + 1));
if (sub == 0)
return (0);
i = 0;
while (i < len && start + i < ft_strlen(s) && s != 0)
{
sub[i] = s[start + i];
i++;
}
sub[i] = 0;
return (sub);
}
ft_strjoin
strjoin 함수는 두 문자열을 합치는 함수입니다.
첫 if문은 해당 두 문자열이 빈 값이 아닌지 확인합니다. 그리고 len_s1, len_s2에 해당 두 문자열의 길이를 할당해줍니다.
그리고 새로운 문자열 ret을 해당 두 길이를 더 한 만큼 할당해줍니다.
마지막으로, strlcpy, strlcat 두 함수를 사용해 빈 문자열 ret을 채워줍니다.
#include "libft.h"
char *ft_strjoin(char const *s1, char const *s2)
{
size_t len_s1;
size_t len_s2;
char *ret;
if (!s1 || !s2)
return (NULL);
len_s1 = ft_strlen(s1);
len_s2 = ft_strlen(s2);
ret = (char *)malloc(sizeof(char) * (len_s1 + len_s2 + 1));
if (!ret)
return (NULL);
ft_strlcpy(ret, s1, len_s1 + 1);
ft_strlcat(ret, s2, len_s1 + len_s2 + 1);
return (ret);
}
ft_strtrim
strtrim 함수는 s1 문자열에서 set을 양쪽에서 제거하는 함수입니다.
if 문을 보면, s1과 set 값 둘 다 빈 값이 아닐 경우, 앞 뒤 둘 다 set이 해당하는지 찾아내어 찾았다면 새로 할당한 front, rear 두 길이를 설정합니다. 새로 만들어낸 문자열의 길이로 사용합니다.
str 이 Null 값인 경우 Null을 리턴합니다.
그렇지 않으면, strlcpy로 앞부분에서 읽었던 인덱스 위치 주소를 넣고 길이는 잘라낸 길이만큼 할당하여 새로운 문자열 str에 복사하여 리턴합니다.
#include "libft.h"
char *ft_strtrim(char const *s1, char const *set)
{
size_t front;
size_t rear;
char *str;
str = 0;
if (s1 != 0 && set != 0)
{
front = 0;
rear = ft_strlen(s1);
while (s1[front] && ft_strchr(set, s1[front]))
front++;
while (s1[rear - 1] && ft_strchr(set, s1[rear - 1]) && rear > front)
rear--;
str = (char *)malloc(sizeof(char) * (rear - front) + 1);
}
if (str == 0)
return (0);
else
{
ft_strlcpy(str, &s1[front], (rear - front + 1));
return (str);
}
}
ft_split
split 함수는 문자열에서 어떤 문자를 기준으로 나눠 문자열을 반환하는 함수입니다.
do_free 함수와 do_split 함수 그리고 ft_word_cnt 함수를 각각 만들어줍니다.
do_free 함수는 동적 할당을 free 해주는 함수입니다.
ft_word_cnt 함수는 c를 제외한 길이를 재는 함수입니다.
do_split 함수는 c를 기준으로 c를 제외하고 새로운 문자열에 채워 넣는 함수입니다.
마지막 리턴 값으로 새 문자열을 리턴합니다.
#include "libft.h"
static char **do_free(char **s)
{
size_t i;
if (s == 0)
return (0);
i = 0;
while (s[i])
{
free(s[i]);
i++;
}
free(s);
s = NULL;
return (NULL);
}
static char **do_split(char **str, char const *s, char c, size_t cnt)
{
size_t i;
size_t j;
size_t next;
i = 0;
j = 0;
while (s[i] && j < cnt)
{
if (s[i] != c)
{
next = i + 1;
while (s[next] && s[next] != c)
next++;
str[j] = ft_substr(s, i, next - i);
if (!str[j])
return (do_free(str));
j++;
i = next;
}
else
i++;
}
str[j] = NULL;
return (str);
}
static int ft_word_cnt(char const *s, char c)
{
size_t i;
size_t cnt;
if (s == 0)
return (0);
i = 0;
cnt = 0;
while (s[i])
{
if (s[i] != c)
{
cnt++;
while ((s[i] != c) && s[i])
i++;
}
else
i++;
}
return (cnt);
}
char **ft_split(char const *s, char c)
{
char **str;
size_t word_cnt;
if (!s)
return (NULL);
word_cnt = ft_word_cnt(s, c);
str = (char **)malloc(sizeof(char *) * (word_cnt + 1));
if (!str)
return (NULL);
if (word_cnt == 0)
{
str[word_cnt] = 0;
return (str);
}
return (do_split(str, s, c, word_cnt));
}
ft_itoa
itoa 함수는 int 자료형을 char 자료형으로 변환하는 함수입니다.
check_length 함수는 int 자료형 길이를 재는 함수입니다.
#include "libft.h"
size_t check_length(int n)
{
size_t nb;
nb = 0;
if (n == 0)
return (1);
if (n < 0)
nb++;
while (n != 0)
{
n = n / 10;
nb++;
}
return (nb);
}
char *ft_itoa(int n)
{
char *str;
size_t length;
long long value;
length = check_length(n);
value = (long long)n;
str = (char *)malloc(sizeof(char) * (length) + 1);
if (str == 0)
return (0);
if (value < 0)
{
str[0] = '-';
value *= -1;
}
if (value == 0)
str[0] = '0';
str[length] = 0;
length -= 1;
while (value)
{
str[length] = value % 10 + '0';
value /= 10;
length--;
}
return (str);
}
ft_strmapi
strmapi 함수는 s 문자열에 f 함수를 적용하는 함수입니다.
문자열 s와 함수 f 가 Null 인지 확인하고 Null 이면 Null 값으로 리턴합니다.
새 문자열 str을 만들고 이 문자열에 f 함수를 적용한 값들을 넣어줍니다.
마지막으로, Null 값을 넣고 새롭게 적용된 문자열을 리턴합니다.
#include "libft.h"
char *ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
size_t length;
size_t i;
char *str;
i = 0;
if (!s || !f)
return (0);
length = ft_strlen(s);
str = (char *)malloc(sizeof(char) * (length) + 1);
if (str == 0)
return (0);
while (i < length)
{
str[i] = f(i, s[i]);
i++;
}
str[i] = 0;
return (str);
}ft_striteri
striteri 함수는 s 문자열을 f 함수에 적용하는 함수입니다.
s와 f 가 Null인지 확인 후 둘 중 하나라도 Null이면 빈 값을 return 합니다.
s 문자열 끝까지 인덱스를 읽고 함수에 문자열을 적용합니다.
#include "libft.h"
void ft_striteri(char *s, void (*f)(unsigned int, char *))
{
int i;
i = 0;
if (s == 0 || f == 0)
return ;
while (s[i])
{
f(i, &s[i]);
i++;
}
}
ft_putchar_fd
fd 가 추가된 함수는 매개변수 인자로 파일 디스크립처를 받아옵니다.
유닉스 시스템에서 프로세스가 특정 파일에 접근하기 위한 추상적인 키로 사용됩니다.
putchar 함수는 단일 문자만 출력합니다.
#include "libft.h"
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, 1);
}
ft_putstr_fd
putstr 함수는 문자열을 출력합니다.
#include "libft.h"
void ft_putstr_fd(char *s, int fd)
{
if ((fd < 0) || !s)
return ;
write(fd, s, ft_strlen(s));
}
ft_putendl_fd
putendl 함수는 끝에 Null 값을 넣어줍니다.
#include "libft.h"
void ft_putendl_fd(char *s, int fd)
{
if (!s || fd < 0)
return ;
write(fd, s, ft_strlen(s));
write(fd, "\n", 1);
}ft_putnbr_fd
putnbr 함수는 기존의 putnbr 함수와 기능적으로 동일하지만 fd을 인자로 받고 write에 파일 디스크립터로 사용합니다.
#include "libft.h"
void ft_putnbr_fd(int n, int fd)
{
char str;
if (n == -2147483648)
{
ft_putnbr_fd(n / 10, fd);
write(fd, "8", 1);
return ;
}
else if (n < 0)
{
write(fd, "-", 1);
n *= -1;
}
if (n >= 10)
{
ft_putnbr_fd(n / 10, fd);
str = '0' + n % 10;
}
else
str = '0' + n;
write(fd, &str, 1);
}
'42Seoul > Libft' 카테고리의 다른 글
| [42Seoul][Libft] 나만의 라이브러리 만들기 - bonus part [C] (0) | 2022.04.12 |
|---|