Jinho Tech

구조체(연결 리스트) 관련 함수들이다. 

Libft 과제의 코드는 이게 마지막이다!! 

ft_lstlast: 연결 리스트의 마지막 list 주소를 반환해주는 함수

t_list	*ft_lstlast(t_list *lst)
{
	if (!lst)
		return (lst);
	while (lst->next)
		lst = lst->next;
	return (lst);
}

ft_lstnew: 새 연결 리스트를 생성해주는 함수(새로운 노드를 선언)

t_list	*ft_lstnew(void *content)
{
	t_list	*lst;

	if (!(lst = (t_list *)malloc(sizeof(t_list))))
		return (NULL);
	lst->content = content;
	lst->next = NULL;
	return (lst);
}

ft_lstmap: 연결 리스트의 모든 content에 함수 f를 적용한 결과를 반환해주는 함수

위에서 구현한 ft_lstnew 함수를 이용해서 새로운 연결 리스트를 생성한 후에, 매개 변수로 받은 연결 리스트의 content에 함수 f를 적용한 결과를 차곡차곡 저장해주면 된다.

t_list	*ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
	t_list	*result;
	t_list	*t;

	if (lst == 0 || f == 0)
		return (NULL);
	if (!(result = ft_lstnew((*f)(lst->content))))
		return (NULL);
	t = result;
	lst = lst->next;
	while (lst)
	{
		if (!(t->next = ft_lstnew((*f)(lst->content))))
		{
			ft_lstclear(&result, del);
			return (NULL);
		}
		t = t->next;
		lst = lst->next;
	}
	return (result);
}

ft_lstsize: 연결 리스트의 길이를 반환해주는 함수

int		ft_lstsize(t_list *lst)
{
	int		len;

	len = 0;
	while (lst)
	{
		lst = lst->next;
		len++;
	}
	return (len);
}

이번 함수들은 구조체(연결 리스트)와 관련된 함수들이다. 

연결 리스트의 형식은 아래와 같다. 

typedef	struct		s_list
{
	void			*content;
	struct s_list	*next;
}					t_list;

ft_lstadd_back: 연결 리스트의 맨 뒤에 새로운 요소를 추가해주는 함수

void	ft_lstadd_back(t_list **lst, t_list *new)
{
	t_list	*lst2;

	lst2 = *lst;
	if (!(*lst))
		*lst = new;
	else
	{
		while (lst2->next)
			lst2 = lst2->next;
		lst2->next = new;
	}
}

ft_lstadd_front: 연결 리스트의 맨 앞에 새로운 요소를 추가해주는 함수

void	ft_lstadd_front(t_list **lst, t_list *new)
{
	new->next = *lst;
	*lst = new;
}

ft_lstclear: 연결 리스트를 초기화해주는 함수(삭제, 메모리 해제)

void	ft_lstclear(t_list **lst, void (*del)(void *))
{
	t_list	*lst2;

	lst2 = *lst;
	if (lst || *lst)
	{
		while (*lst)
		{
			*lst = lst2->next;
			del(lst2->content);
			free(lst2);
			lst2 = *lst;
		}
	}
}

ft_lstdelone: 연결 리스트의 content를 삭제하고 메모리를 해제해주는 함수

void	ft_lstdelone(t_list *lst, void (*del)(void *))
{
	if (lst)
	{
		del(lst->content);
		free(lst);
	}
}

ft_lstiter: 연결 리스트의 모든 content에 함수 f를 적용해주는 함수

void	ft_lstiter(t_list *lst, void (*f)(void *))
{
	while (lst)
	{
		f(lst->content);
		lst = lst->next;
	}
}

ft_strrchr: 문자열 s의 뒤에서부터 문자 c를 찾아 그 위치를 반환해주는 함수

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

	i = (int)ft_strlen(s) + 1;
	while (i--)
	{
		if (s[i] == (char)c)
			return ((char *)s + i);
	}
	return (NULL);
}

ft_strtrim: 문자열 s1에서 앞, 뒤에 문자열 set을 자른 문자열을 반환해주는 함수

start = 0 -> s1의 맨 앞에서부터 set 값이 없을 때까지 start 증가

end = ft_strlen(s1) -> s1의 맨 뒤에서부터 set 값이 없을 때까지 end 감소

새 문자열 str에 end - start + 1 만큼의 메모리를 할당해주고 s1의 start부터 end까지의 값들을 복사해주면 된다.

마지막에 null을 넣어주는 것을 잊지 말자!

int		ft_setcheck(char c, char const *set)
{
	int	i;

	i = 0;
	while (set[i])
	{
		if (set[i++] == c)
			return (1);
	}
	return (0);
}

char	*ft_strtrim(char const *s1, char const *set)
{
	char	*str;
	int		start;
	int		end;
	int		i;

	i = 0;
	start = 0;
	if (s1 == 0 || set == 0)
		return (NULL);
	end = (int)ft_strlen(s1);
	while (s1[start] && ft_setcheck(s1[start], set))
		start++;
	while (end > start && ft_setcheck(s1[end - 1], set))
		end--;
	if (!(str = (char *)malloc(sizeof(char) * (end - start + 1))))
		return (NULL);
	while (start < end)
		str[i++] = s1[start++];
	str[i] = '\0';
	return (str);
}

ft_substr: 문자열 s의 start번째 인덱스부터 시작하는 크기가 len인 문자열을 반환해주는 함수

start가 문자열 s의 길이보다 크거나 같을 때만 잘 처리해주면 된다. ft_strdup을 사용해서 빈 문자열을 반환해줬다.

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

	i = 0;
	if (s == 0)
		return (NULL);
	if (start >= ft_strlen(s))
		return (ft_strdup(""));
	if (!(str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	while (s[i] && i < len)
		str[i++] = s[start++];
	str[i] = 0;
	return (str);
}

ft_tolower: 매개변수로 들어오는 값이 대문자면 소문자로 바꿔주는 함수

int	ft_tolower(int c)
{
	if (c >= 65 && c <= 90)
		return (c + 32);
	return (c);
}

ft_toupper: 매개변수로 들어오는 값이 소문자면 대문자로 바꿔주는 함수

int	ft_toupper(int c)
{
	if (c >= 97 && c <= 122)
		return (c - 32);
	return (c);
}

ft_strlen: 문자열의 길이를 반환해주는 함수

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

	i = 0;
	while (s[i])
		i++;
	return (i);
}

ft_strmapi: 문자열 s의 각 인덱스에 담긴 값에 함수 f를 적용한 결과를 반환해주는 함수

함수를 파라미터로 받는 함수이다. 

char	*ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
	int		i;
	int		len;
	char	*str;

	i = 0;
	if (s == 0 || f == 0)
		return (NULL);
	len = (int)ft_strlen(s);
	if (!(str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	while (i < len)
	{
		str[i] = f(i, s[i]);
		i++;
	}
	str[i] = '\0';
	return (str);
}

ft_strncmp: 두 문자열 s1, s2를 n만큼 비교하여 그 차이를 반환해주는 함수

문자열 s1과 문자열 s2을 첫 인덱스부터 순서대로 비교하는데

s1과 s2가 끝까지 같다면 0을 반환하고, 같지 않다며 해당 위치의 s1 - s2 값을 반환해주면 된다.

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

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

ft_strnstr: 문자열 big에서 문자열 little과 일치하는 문자열의 위치를 반환해주는 함수

문자열 big의 첫 인덱스부터 문자열 little의 첫 문자와 같은 문자가 있는지 확인을 한다.

같은 문자가 있다면 반복문을 하나 더 파서 big의 뒷 문자들이 little과 똑같은지 확인을 해주면 된다.

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

	i = 0;
	little_len = ft_strlen(little);
	if (!little_len)
		return ((char *)big);
	while (big[i] && i + little_len <= n)
	{
		if (big[i] == little[0])
		{
			j = 0;
			while (big[i + j] && little[j])
			{
				if (big[i + j] != little[j])
					break ;
				else if (j == little_len - 1)
					return ((char *)big + i);
				j++;
			}
		}
		i++;
	}
	return (NULL);
}

이번 함수들은 문자열과 관련된 함수들이다.

ft_strchr: 문자열 s에서 문자 c를 찾아 그 위치를 반환해주는 함수

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

	i = 0;
	while (i < (int)ft_strlen(s) + 1)
	{
		if (s[i] == (char)c)
			return ((char *)s + i);
		i++;
	}
	return (NULL);
}

ft_strdup: 문자열 s를 복사한 문자열을 반환해주는 함수

새 문자열에 s의 길이 + 1 만큼 할당해주고 s를 그대로 복사해주면 된다. 마지막에 null을 넣어주는 것을 잊지 말자!

char	*ft_strdup(const char *s)
{
	char	*str;
	int		i;
	int		slen;

	i = 0;
	slen = (int)ft_strlen(s);
	if (!(str = (char *)malloc(sizeof(*s) * (slen + 1))))
		return (NULL);
	while (s[i])
	{
		str[i] = s[i];
		i++;
	}
	str[i] = '\0';
	return (str);
}

ft_strjoin: 두 문자열을 s1, s2를 합친 문자열을 반환해주는 함수

새 문자열에 s1의 길이 + s2의 길이 + 1 만큼 할당해주고, s1과 s2를 순서대로 복사해주면 된다. 

마지막에 null을 넣어주는 것을 잊지 말자!

char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*str;
	int		i;
	int		j;
	int		s1_len;
	int		s2_len;

	i = 0;
	j = 0;
	if (s1 == 0 || s2 == 0)
		return (NULL);
	s1_len = (int)ft_strlen(s1);
	s2_len = (int)ft_strlen(s2);
	if (!(str = (char *)malloc(sizeof(char) * (s1_len + s2_len + 1))))
		return (NULL);
	while (i < s1_len)
	{
		str[i] = s1[i];
		i++;
	}
	while (j < s2_len)
		str[i++] = s2[j++];
	str[i] = '\0';
	return (str);
}

ft_strlcat: 문자열 dst에 문자열 src를 이어 붙이고, 그 길이를 반환하는 함수

dest의 길이가 size보다 크면 size + src의 길이를 반환하고

dest의 길이가 size보다 크지 않으면 dest의 길이 + src길이를 반환해주면 된다.

size_t	ft_strlcat(char *dst, const char *src, size_t size)
{
	size_t	i;
	int		j;
	size_t	k;

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

ft_strlcpy: size만큼 문자열 src를 문자열 dst에 복사하고, src의 크기를 반환해주는 함수

src를 size만큼만 복사해주면 된다.

strlcat 함수도 그렇고 복사해준 src의 길이가 아니라 src의 크기 그 자체를 반환하는 게 조금 아이러니한 것 같다.

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

	i = 0;
	if (dst == 0 || src == 0)
		return (0);
	src_len = ft_strlen(src);
	if (size > 0)
	{
		while (i < (size - 1) && src[i])
		{
			dst[i] = src[i];
			i++;
		}
		dst[i] = '\0';
	}
	return (src_len);
}

이번 함수들은 다 출력과 관련된 함수들이다. write 함수를 잘 사용해주면 된다.

ft_putchar_fd: c문자를 fd파일 디스크립터 형식으로 출력해주는 함수

write 함수의 파라미터는 순서대로 디스크립터, 문자, 크기이므로 그냥 아래와 같이 짜주면 된다.

void	ft_putchar_fd(char c, int fd)
{
	write(fd, &c, 1);
}

ft_putstr_fd: 문자열을 fd파일 디스크립터 형식으로 출력해주는 함수

write 함수로 문자열을 모두 출력하려면 그 길이를 알 필요가 있기에 문자열의 길이를 반환해주는 ft_strlen 함수를 사용했다. 

void	ft_putstr_fd(char *s, int fd)
{
	if (s == 0)
		return ;
	write(fd, s, ft_strlen(s));
}

ft_putendl_fd: 끝에 '\n'이 추가된 문자열을 fd파일 디스크립터 형식으로 출력해주는 함수

ft_putstr_fd 함수에서 마지막에 '\n'을 출력하는 부분만 추가해주면 된다.

void	ft_putendl_fd(char *s, int fd)
{
	if (s == 0)
		return ;
	write(fd, s, ft_strlen(s));
	write(fd, "\n", 1);
}

ft_putnbr_fd: 숫자 n을 fd파일 디스크립터 형식으로 출력해주는 함수

재귀적으로 앞에 숫자부터 하나씩 출력하는 방식이다.

음수일 때는 '-'를 먼저 출력하고 양수로 바꿔서 똑같이 출력해주면 된다.

단 -2147483648의 경우 양수로 바꿨을 때 오버플로가 발생하게 되므로 따로 처리를 해줘야 한다.

'-'와 '2'를 먼저 출력한 후에 147483648을 출력하는 방식으로 처리했다. 

void	ft_putnbr_fd(int n, int fd)
{
	if (n < 0)
	{
		ft_putchar_fd('-', fd);
		n *= -1;
	}
	if (n == -2147483648)
	{
		ft_putchar_fd('2', fd);
		n = -(n % 1000000000);
	}
	if (n >= 10)
	{
		ft_putnbr_fd(n / 10, fd);
		ft_putnbr_fd(n % 10, fd);
	}
	else
		ft_putchar_fd(n + '0', fd);
}

이 함수들은 예전에 형변환을 잘못해서 귀찮았던 적이 있었던 것 같다.

구현하기 쉽고 다들 비슷한 형태이다. 

ft_memcpy: 문자열 src를 n만큼 dest에 복사해주는 함수, 마지막에 dest를 반환해준다.

void	*ft_memcpy(void *dest, const void *src, size_t n)
{
	char	*dest2;
	char	*src2;
	size_t	i;

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

ft_memccpy: 문자열 src를 n만큼 dest에 복사하되 문자 c까지만 복사해주는 함수
dest에서 c문자가 위치한 위치의 다음 주소를 반환해준다.

void	*ft_memccpy(void *dest, const void *src, int c, size_t n)
{
	char			*ptr1;
	unsigned char	*ptr2;
	size_t			i;

	ptr1 = dest;
	ptr2 = (unsigned char *)src;
	i = 0;
	while (i < n)
	{
		ptr1[i] = ptr2[i];
		if (ptr2[i] == (unsigned char)c)
			return (dest + i + 1);
		i++;
	}
	return (NULL);
}

ft_memchr: 문자열 s에서 n 크기 안에 문자 c가 있으면 해당 포인터를, 없다면 null을 반환해주는 함수

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

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

ft_memcmp: 문자열 s1, s2를 n만큼 비교하는 함수

비교 도중 다르다면 두 개를 뺀 값을 반환, 끝까지 똑같다면 0을 반환해주면 된다.

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

	s11 = (unsigned char *)s1;
	s22 = (unsigned char *)s2;
	i = 0;
	while (i < n && s11[i] == s22[i])
    {
		if (s11[i] != s22[i])
			return (s11[i] - s22[i]);
        i++;
    }
	return (0);
}

ft_memmove: 문자열 src를 n만큼 dest에 옮겨주는 함수

dest의 주소가 src의 주소보다 뒤에 있을 경우에는 주소가 겹칠 수도 있기에 이 경우에는 따로 처리를 해줘야 된다!

dest <= src 라면 그냥 0부터 n까지 (앞에부터) 옮겨주고, dest > src의 경우에는 n부터 0까지(뒤에서부터) 옮겨주면 된다.

EX) dest > src의 경우를 따로 처리하지 않았을 때 -> 앞에서 부터 처리하므로 겹쳐서 꼬일 수도 있음

s = "01234";

dest = s + 2; src = s + 1; n = 2; 라고 치면 처음엔 dest = "134", src = "1134", s = "01134"가 되고

그 다음번엔 dest = "114", src = "1114", s = "01114"가 되어 정말 꼬이게 된다.

EX) dest > src의 경우를 따로 처리했을 때 -> 뒤에서 부터 처리하므로 겹칠수가 없다.

처음엔 dest = "224", src = "1224", s = "01224"가 되고

그 다음번엔 dest = "124", src = "1124", s = "01124"가 된다.

void	*ft_memmove(void *dest, const void *src, size_t n)
{
	char	*dest2;
	char	*src2;
	size_t	i;

	dest2 = (char *)dest;
	src2 = (char *)src;
	i = -1;
	if (!dest && !src)
		return (NULL);
	if (dest2 > src2)
		while ((int)(--n) >= 0)
			dest2[n] = src2[n];
	else
		while (++i < n)
			dest2[i] = src2[i];
	return (dest);
}

ft_split: 문자열을 특정 문자 기준으로 쪼개서 이중 포인터에 저장하여 반환해주는 함수

ft_split("a12aaa12", 'a') = ["12", "12"]과 같은 방식으로 특정 문자가 덕지덕지 붙어있는 경우에도 잘 처리해야 한다.

1) 일단 이중 포인터를 할당해야 되기 때문에 문자열에서 분해되는 단어가 몇 개 일지를 미리 파악해야 한다.

이는 ft_word_count 함수에서 처리한다. 처리 방식은 아래 split 하는 방식과 거의 유사하다. 

2) 문자열 맨 처음부터 들어있는 c들은 무시 즉 c가 아닌 다른 문자가 보일 때까지 문자열을 넘어가야 한다. 왜냐하면 앞에 쪼개서 저장할 문자가 없기 때문이다. 

ex) ft_split("aaa11a", 'a') = ["11"] -> 보면 앞에 있는 a들은 아무 의미가 없다. '1'까지 넘어가 주면 된다.

3) c가 아닌 문자가 보였다면 그 위치부터 그다음에 있는 c의 위치 전까지의 문자들을 이중 포인터에 차례대로 저장해주면 된다. 

그 후에 문자열 끝까지 2와 3을 반복해주면 된다.

ex)  ft_split("aaa12aa345a", 'a') = ["12", "345"] -> 12, 345가 이중 포인터에 차례대로 저장된다.

쪼갠 단어를 이중 포인터에 저장하는 건 ft_word_make 함수, 실제로 문자열을 쪼개는 건 ft_split2 함수이다. 

int		ft_word_count(char const *s, char c)
{
	int	i;
	int	cnt;

	i = 0;
	cnt = 0;
	while (s[i])
	{
		if (s[i] == c)
			i++;
		else
		{
			cnt++;
			while (s[i] && s[i] != c)
				i++;
		}
	}
	return (cnt);
}

char	*ft_word_make(char *word, char const *s, int k, int word_len)
{
	int		i;

	i = 0;
	while (word_len > 0)
		word[i++] = s[k - word_len--];
	word[i] = '\0';
	return (word);
}

char	**ft_split2(char **result, char const *s, char c, int word_num)
{
	int		i;
	int		k;
	int		word_len;

	i = 0;
	k = 0;
	word_len = 0;
	while (s[k] && i < word_num)
	{
		while (s[k] && s[k] == c)
			k++;
		while (s[k] && s[k] != c)
		{
			k++;
			word_len++;
		}
		if (!(result[i] = (char *)malloc(sizeof(char) * (word_len + 1))))
			return (NULL);
		ft_word_make(result[i], s, k, word_len);
		word_len = 0;
		i++;
	}
	result[i] = 0;
	return (result);
}

char	**ft_split(char const *s, char c)
{
	int		word_num;
	char	**result;

	if (s == 0)
		return (NULL);
	word_num = ft_word_count(s, c);
	if (!(result = (char **)malloc(sizeof(char *) * (word_num + 1))))
		return (NULL);
	ft_split2(result, s, c, word_num);
	return (result);
}

github.com/kimjinho1/Libft

ft_atoi: 문자열을 정수로 바꿔주는 함수

ex) ft_atoi("   -1234") = -1234

구현 과정은 간단하게 3가지로 설명 가능할 것 같다. 

1) 입력으로 주어진 문자열에서 앞부분 공백들을 모두 넘어가야 함

2) 공백을 전부 넘어간 다음에 - or + 가 있다면 다음칸으로 넘어감. 만약 - 였다면 sign 변수를 1에서 -1로 바꾼다

3) 0~9 이외의 문자가 나올 때까지 숫자를 계속 업데이트함(n = 10*n + nptr[i])

     업데이트 중에 숫자가 int 타입의 범위를 넘어버리는 경우는 따로 처리를 해줘야 한다(while 문 안에 if, else if 문)

int	ft_atoi(const char *nptr)
{
	int			i;
	int			sign;
	long long	n;

	i = 0;
	sign = 1;
	n = 0;
	while (nptr[i] == ' ' || nptr[i] == '\n' || nptr[i] == '\t' ||
			nptr[i] == '\v' || nptr[i] == '\f' || nptr[i] == '\r')
		i++;
	if (nptr[i] == '-')
		sign *= -1;
	if (nptr[i] == '-' || nptr[i] == '+')
		i++;
	while (nptr[i] && nptr[i] >= '0' && nptr[i] <= '9')
	{
		if (n * sign > 2147483647)
			return (-1);
		else if (n * sign < -2147483648)
			return (0);
		else
			n = n * 10 + (nptr[i] - '0');
		i++;
	}
	return (n * sign);
}

ft_itoa: 정수를 문자열로 바꿔주는 함수

atoi의 반대 버전이지만 구현하는 데 아주 조금 힘이 더 든다. 포인트는 배열의 뒷부분부터 채운다는 점인데

ex) n = 123이면 [][][] -> [][][3] -> [][2][3] -> [1][2][3]과 같은 방식으로 문자열에 채워진다.

입력이 음수일 때는 맨 앞에 '-'가 들어가야 하므로 기본 문자열보다 1개 큰 문자열을 할당해줘야 하고 숫자를 채울 때도 주의해줘야 한다.

ex) n = -123이면 [][][][] -> [-][][][] -> [-][][][3] -> [-][][2][3]-> [-][1][2][3]

long long	ft_abs(int n)
{
	long long n2;

	n2 = n;
	if (n < 0)
		return (n2 * -1);
	return (n2);
}

int			ft_intlen(int n)
{
	int			len;
	long long	n2;

	len = 1;
	n2 = ft_abs(n);
	while (n2 /= 10)
		len++;
	return (len);
}

char		*ft_itoa(int n)
{
	char		*str;
	long long	n2;
	int			i;
	int			len;

	n2 = ft_abs(n);
	i = 1;
	len = ft_intlen(n);
	if (n < 0)
		len++;
	if (!(str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	if (n < 0)
		str[0] = '-';
	while (i <= len)
	{
		if (str[len - i] != '-')
			str[len - i] = (n2 % 10) + '0';
		n2 /= 10;
		i++;
	}
	str[len] = '\0';
	return (str);
}

github.com/kimjinho1/Libft

여기 부분은 함수들이 정말 간단하고 거의 똑같다.

ft_isalpha: 입력 c가 알파벳이면 참, 아니면 거짓 을 반환해주는 함수

아스키코드를 사용했는데 그냥 문자로 구현해도 똑같다. (65 = 'A' ,90 = 'Z', 97 = 'a', 122 = 'z')

int	ft_isalpha(int c)
{
	return ((c >= 65 && c <= 90) || (c >= 97 && c <= 122));
}

ft_isdigit: 입력 c가 숫자이면 참, 아니면 거짓을 반환해주는 함수

isalpha와 똑같은 방식으로 구현했다. (48 = '0', 57 = '9')

int	ft_isdigit(int c)
{
	return (c >= 48 && c <= 57);
}

ft_isalnum: 입력 c가 알파벳 or 숫자이면 참, 아니면 거짓을 반환해주는 함수

구현에 isalpha와 isdigit을 사용했다.

int	ft_isalnum(int c)
{
	return (ft_isalpha(c) || ft_isdigit(c));
}

ft_isascii: 입력 c가 아스키코드 내 값이면 참, 아니면 거짓을 반환해주는 함수

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

ft_isprint: 입력 c가 출력될 수 있는 문자면 참, 아니면 거짓을 반환해주는 함수

32부터 126까지가 출력 가능한 아스키코드 값이다(32 = space, 126 = '~') 

참고로 마지막 아스키코드인 127은 Delete

int	ft_isprint(int c)
{
	return (c >= 32 && c <= 126);
}

github.com/kimjinho1/Libft

코드는 자기가 짜다가 정말 모르겠다 싶을 때 보는 것이 제일 효율이 좋은 거 같다.

그리고 이 코드가 꼭 정답인 것도 아니다. 더 좋은 방법이 있을 수 있다. 이 글을 보는 사람들도 주의하면 좋겠다.

libft 과제에서는 실제로 존재하는 함수들을 우리가 직접 구현해야 한다. 

42서울 학생이신 분들은 다 알겠지만 norm 때문에 구현이 좀 귀찮아지는 함수들도 몇 개 있었던 것 같다. ft_split 등등

ft_bzero: 원하는 메모리 영역을 0으로 채워주는 함수

말 그대로 s를 n만큼 0으로 채워주면 된다.

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

	ptr = s;
	i = 0;
	while (i < n)
		ptr[i++] = 0;
}

ft_memset: 원하는 메모리 영역을 c로 채워주는 함수

앞에서 본 bzero와 거의 똑같은 함수이다. bzero에선 0을 memset에선 입력 c를 채워준다. 

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

	ptr = s;
	i = 0;
	while (i < n)
		ptr[i++] = c;
	return (s);
}

ft_calloc: 원하는 크기만큼의 메모리를 할당하고 그 공간을 0으로 채워주는 함수

bzero와 거의 동일하지만 bzero는 이미 할당되어있던 메모리를 0으로 채운다면

calloc은 메모리를 새로 할당한 후에 0으로 채워준다. 코드 구현에 memset 함수를 사용했다. 

void	*ft_calloc(size_t nmemb, size_t size)
{
	char	*ptr;

	if (!(ptr = (char *)malloc(sizeof(*ptr) * nmemb * size)))
		return (NULL);
	ft_memset(ptr, 0, nmemb * size);
	return (ptr);
}

github.com/kimjinho1/Libft