필요 개념 및 학습 내용

libft

모의 테스트 돌리는 방법

bash ~/Libftest/grademe.sh

Part1

C의 표준라이브러리 Libc의 함수들을 이미테이션하여 만든다.

isalpha

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

설명 생략

isdigit

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

설명 생략

isalnum

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

설명 생략

isascii

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

설명 생략

isprint

int	ft_isprint(int c)
{
	if (c >= 32 && c <= 126)
		return (1);
	else
		return (0);
}

설명 생략

strlen

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

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

문자열을 인자로 받아 문자열의 길이를 반환한다.

파라미터 인자로 받는 const char * s 상수 키워드. 즉, 원본 데이터는 유지하는 것이 설계 목적인 점 이해하고 넘어가는 것이 좋다

memset

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

	data = (unsigned char *)s;
	while (n--)
	{
		*data = (unsigned char)c;
		data++;
	}
	return (s);
}

메모리의 값을 특정값으로 세팅할 수 있는 함수이다.

s에 n 만큼 c 로 세팅한다

성공한다면 원래 메모리 주소를 반환하고, 실패한다면 NULL을 반환하게 된다.

인자값으로 void 형 포인터를 받고 있으므로 unsigned char * 로 변경 필요

char

[00000001]

또한 int형 배열의 경우 내부에서는 메모리 블럭으로 4byte씩 [00000000][00000000][00000000][00000001] -> 1 를 기대하겠지만 memset내부에서 메모리블럭을 1byte로 구해버려서 [00000001][00000001][00000001][00000001] -> 16843009 값으로 초기화 되어버린다.

bzero

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

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

memset 과 비슷한 기능을 수행함. 다만 memset과 다르게 인자값으로 int c를 받지 않는다. 0으로 초기화해준다는 의미이다.

memcpy

void	*ft_memcpy(void *dest, const void *src, size_t n)
{
	unsigned char		*_dest;
	const unsigned char	*_src;

	_dest = (unsigned char *)dest;
	_src = (const unsigned char *)src;
	if (_dest == _src)
		return (dest);
	while (n--)
	{
		*_dest = *_src;
		_dest++;
		_src++;
	}
	return (dest);
}

memmove 와 함께 묶여서 말이 많은 함수이다.

dest에 src로부터 n만큼 copy해준다.

다만 dest와 src가 겹치면 동작이 되지 않는다.

memmove

void	*ft_memmove(void *dest, const void *src, size_t n)
{
	size_t				i;
	unsigned char		*_dest;
	const unsigned char	*_src = (const unsigned char *)src;

	i = 0;
	_dest = (unsigned char *)dest;
	if (dest > src)
	{
		while (n--)
			_dest[n] = _src[n];
	}
	if (dest < src)
	{
		while (n--)
		{
			_dest[i] = _src[i];
			i++;
		}
	}
	return (dest);
}

dest에 src로부터 n만큼 copy해준다. 그러나 memcpy 와 다르게 두 문자열이 겹칠 수 있고, 복사된 내용도 훼손되지 않아야 한다.

strlcpy

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

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

strlcat

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

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

toupper

int	ft_toupper(int c)
{
	int	diff;

	diff = 'A' - 'a';
	if (c >= 'a' && c <= 'z')
		c += diff;
	return (c);
}

tolower

int	ft_tolower(int c)
{
	int	diff;

	diff = 'A' - 'a';
	if (c >= 'A' && c <= 'Z')
		c -= diff;
	return (c);
}

strchr

char	*ft_strchr(const char *s, int c)
{
	while (*s)
	{
		if (*s == (unsigned char)c)
			return ((char *)s);
		s++;
	}
	if (*s == (unsigned char)c)
		return ((char *)s);
	return (0);
}

strrchr

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

	i = 0;
	while (*s)
	{
		s++;
		i++;
	}
	while (i >= 0)
	{
		if (*s == (unsigned char)c)
			return ((char *)s);
		s--;
		i--;
	}
	return (0);
}

strncmp

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

	i = 0;
	_s1 = (unsigned char *)s1;
	_s2 = (unsigned char *)s2;
	while (*_s1 && *_s2 && i < n)
	{
		if (*_s1 != *_s2)
			return (*_s1 - *_s2);
		_s1++;
		_s2++;
		i++;
	}
	if (i != n)
		return (*_s1 - *_s2);
	return (0);
}

memchr

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

	dst = (unsigned char *)s;
	while (n--)
	{
		if (*dst == (unsigned char)c)
			return (dst);
		dst++;
	}
	return (0);
}

memcmp

int	ft_memcmp(const void *s1, const void *s2, size_t n)
{
	const unsigned char	*pt1 = (unsigned char *)s1;
	const unsigned char	*pt2 = (unsigned char *)s2;

	while (n--)
	{
		if (*pt1 != *pt2)
			return (*pt1 - *pt2);
		pt1++;
		pt2++;
	}
	return (0);
}

strnstr

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

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

atoi

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

	num = 0;
	sign = 1;
	i = 0;
	while (nptr[i] == ' ' || (nptr[i] >= 9 && nptr[i] <= 13))
		i++;
	if (nptr[i] == '+' && (nptr[i + 1] >= '0' && nptr[i + 1] <= '9'))
		i++;
	if (nptr[i] == '-' && (nptr[i + 1] >= '0' && nptr[i + 1] <= '9'))
	{
		sign *= -1;
		i++;
	}
	while (nptr[i] >= '0' && nptr[i] <= '9')
	{
		num = num * 10 + (nptr[i] - '0');
		i++;
	}
	return (sign * num);
}

들어온 문자열을 숫자로 반환하는 함수

문자열의 처음 공백 부분은 전부 무시한다.
문자열은 처음 +,-기호를 인식한다.
앞선 규칙들을 포함하여 숫자만을 인식하여 int으로 변환한다.

libc 에서의 atoi 함수는 LONG_MAX과 LONG_MIN 의 범위를 넘어갔을 때 0과 -1을 리턴하지만, libft에서는 오버/언더플로우 처리값까지는 신경쓰지 않으므로 무시해도 괜찮다.

ft_atoi 삽질한 선배님 자료

원리

calloc

#include <limits.h>

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

	if (nmemb != 0 && size > UINT_MAX / nmemb)
		return (NULL);
	total_size = nmemb * size;
	ptr = malloc(total_size);
	if (ptr == NULL)
	{
		return (NULL);
	}
	ft_memset(ptr, 0, total_size);
	return (ptr);
}

strdup

char	*ft_strdup(const char *s)
{
	char	*result;
	size_t	i;

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

Part2

libc에 포함되어 있지 않거나 다른 형식으로 포함된 함수들을 재구현한다.

ft_substr

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

	i = 0;
	if (s == 0)
		return (0);
	size = ft_strlen(s);
	if (size < start)
		len = 0;
	else if (len > size - start)
		len = size - start;
	sc = (char *)malloc(sizeof(char) * (len + 1));
	if (sc == NULL)
		return (0);
	while (len--)
	{
		sc[i] = s[start];
		start++;
		i++;
	}
	sc[i] = '\0';
	return (sc);
}

int	main(void)
{
	char	*test1;
	char	*result;

	// 테스트 케이스들
	test1 = "Hello, World!";
	// Test case 1: 정상적으로 부분 문자열 추출 (start = 7, len = 5)
	result = ft_substr(test1, 7, 5);
	if (result != NULL)
	{
		printf("Test 1 (start=7, len=5): %s\n", result); // 기대 결과: "World"
		free(result);
	}
	// Test case 2: 시작 위치가 전체 길이보다 큰 경우 (start = 20)
	result = ft_substr(test1, 20, 5);
	if (result != NULL)
	{
		printf("Test 2 (start=20, len=5): %s\n", result); // 기대 결과: ""
		free(result);
	}
	// Test case 3: 부분 문자열의 길이가 문자열 끝을 넘는 경우 (start = 7, len = 10)
	result = ft_substr(test1, 7, 10);
	if (result != NULL)
	{
		printf("Test 3 (start=7, len=10): %s\n", result); // 기대 결과: "World!"
		free(result);
	}
	// Test case 4: 시작 위치가 0인 경우 (start = 0, len = 5)
	result = ft_substr(test1, 0, 5);
	if (result != NULL)
	{
		printf("Test 4 (start=0, len=5): %s\n", result); // 기대 결과: "Hello"
		free(result);
	}
	// Test case 5: 길이가 0인 경우 (start = 5, len = 0)
	result = ft_substr(test1, 5, 0);
	if (result != NULL)
	{
		printf("Test 5 (start=5, len=0): %s\n", result); // 기대 결과: ""
		free(result);
	}
	return (0);
}

substr는 s의 문자열에서 start의 길이에서 len길이만큼 복사하여 새로운 문자열을 반환하는 함수이다.

s의 null처리
s의 길이가 start의 길이보다 작을 경우 빈 문자열 반환
문자열이기 때문에 ‘\0’문자 처리 +1 처리해야함

ft_strjoin

char	*ft_strjoin(char const *s1, char const *s2)
{
	size_t	i;
	size_t	j;
	char	*sc;

	i = 0;
	j = 0;
	sc = (char *)ft_calloc((ft_strlen(s1) + ft_strlen(s2) + 1), sizeof(char));
	if (sc == NULL)
		return (0);
	while (s1[i])
	{
		sc[i] = s1[i];
		i++;
	}
	while (s2[j])
	{
		sc[i + j] = s2[j];
		j++;
	}
	return (sc);
}

int	main(void)
{
	char	*result;

	// 테스트 케이스들
	// Test case 1: 두 문자열을 정상적으로 결합
	result = ft_strjoin("Hello, ", "World!");
	if (result != NULL)
	{
		printf("Test 1: %s\n", result); // 기대 결과: "Hello, World!"
		free(result);
	}
	// Test case 2: 첫 번째 문자열이 빈 문자열인 경우
	result = ft_strjoin("", "World!");
	if (result != NULL)
	{
		printf("Test 2: %s\n", result); // 기대 결과: "World!"
		free(result);
	}
	// Test case 3: 두 번째 문자열이 빈 문자열인 경우
	result = ft_strjoin("Hello, ", "");
	if (result != NULL)
	{
		printf("Test 3: %s\n", result); // 기대 결과: "Hello, "
		free(result);
	}
	// Test case 4: 두 문자열 모두 빈 문자열인 경우
	result = ft_strjoin("", "");
	if (result != NULL)
	{
		printf("Test 4: %s\n", result); // 기대 결과: ""
		free(result);
	}
	// Test case 5: 큰 문자열 결합
	result = ft_strjoin("This is a long string ",
			"and this is another long string.");
	if (result != NULL)
	{
		printf("Test 5: %s\n", result);
			// 기대 결과: "This is a long string and this is another long string."
		free(result);
	}
	return (0);
}

s1뒤에 s2를 붙인 새로운 문자열을 반환한다.

s1과 s2의 길이체크 및 널문자 삽입

ft_strtrim

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

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

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

	i = 0;
	start = 0;
	end = ft_strlen(s1);
	while (s1[start] && is_check(s1[start], set))
		start++;
	while (end > start && is_check(s1[end - 1], set))
		end--;
	sc = (char *)malloc(sizeof(char) * (end - start + 1));
	if (sc == NULL)
		return (0);
	while (end > start)
	{
		sc[i] = s1[start];
		i++;
		start++;
	}
	sc[i] = '\0';
	return (sc);
}

int	main(void)
{
	char	*result;

	// Test case 1: 앞뒤 공백 제거
	result = ft_strtrim("   Hello, World!   ", " ");
	if (result != NULL)
	{
		printf("Test 1: '%s'\n", result); // 기대 결과: 'Hello, World!'
		free(result);
	}
	// Test case 2: 앞뒤 특정 문자 제거
	result = ft_strtrim("--Hello--", "-");
	if (result != NULL)
	{
		printf("Test 2: '%s'\n", result); // 기대 결과: 'Hello'
		free(result);
	}
	// Test case 3: 문자 집합에 포함되지 않는 경우 (변화 없음)
	result = ft_strtrim("Hello", "-");
	if (result != NULL)
	{
		printf("Test 3: '%s'\n", result); // 기대 결과: 'Hello'
		free(result);
	}
	// Test case 4: 문자열이 모두 문자 집합으로만 구성된 경우
	result = ft_strtrim("-----", "-");
	if (result != NULL)
	{
		printf("Test 4: '%s'\n", result); // 기대 결과: ''
		free(result);
	}
	// Test case 5: 빈 문자열인 경우
	result = ft_strtrim("", "-");
	if (result != NULL)
	{
		printf("Test 5: '%s'\n", result); // 기대 결과: ''
		free(result);
	}
	// Test case 6: 문자 집합이 빈 문자열인 경우 (변화 없음)
	result = ft_strtrim("Hello", "");
	if (result != NULL)
	{
		printf("Test 6: '%s'\n", result); // 기대 결과: 'Hello'
		free(result);
	}
	return (0);
}

s1문자열의 양끝에서 set문자열을 제거하는 함수이다.

ft_strchr(3)을 사용하여 set을 검사하여 풀이한다.

ft_split

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

	i = 0;
	in_word = 0;
	while (*s)
	{
		if (*s != c && in_word == 0)
		{
			in_word = 1;
			i++;
		}
		else if (*s == c)
			in_word = 0;
		s++;
	}
	return (i);
}

int	ft_cpy(char **sp, char const *start, char const *s, int j)
{
	int	len;
	int	k;

	len = s - start;
	k = 0;
	sp[j] = (char *)malloc(sizeof(char) * (len + 1));
	if (sp[j] == NULL)
	{
		while (j-- > 0)
			free(sp[j]);
		free(sp);
		return (0);
	}
	while (k < len)
	{
		sp[j][k] = start[k];
		k++;
	}
	sp[j][k] = '\0';
	return (1);
}

char	**nom(char **sp, char const *s, char c)
{
	char const	*start;
	int			j;

	j = 0;
	while (*s)
	{
		while (*s && (*s == c))
			s++;
		start = s;
		if (*s && (*s != c))
		{
			while (*s && (*s != c))
				s++;
			if (ft_cpy(sp, start, s, j) == 0)
				return (0);
			j++;
		}
	}
	sp[j] = 0;
	return (sp);
}

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

	if (s == 0)
		return (0);
	sc = (char **)malloc(sizeof(char *) * (ft_wordlen(s, c) + 1));
	if (sc == NULL)
		return (0);
	return (nom(sc, s, c));
}
int	main(void)
{
	char	**result;

	// Test case 1: 문자열을 공백으로 나눔
	result = ft_split("Hello world this is a test", ' ');
	if (result != NULL)
	{
		printf("Test 1: ");
		for (int i = 0; result[i] != NULL; i++)
		{
			printf("'%s' ", result[i]);
		}
		printf("\n");
		free_split(result);
	}
	// Test case 2: 문자열을 쉼표로 나눔
	result = ft_split("one,two,three,four", ',');
	if (result != NULL)
	{
		printf("Test 2: ");
		for (int i = 0; result[i] != NULL; i++)
		{
			printf("'%s' ", result[i]);
		}
		printf("\n");
		free_split(result);
	}
	// Test case 3: 문자열에 구분자가 없을 때
	result = ft_split("HelloWorld", ' ');
	if (result != NULL)
	{
		printf("Test 3: ");
		for (int i = 0; result[i] != NULL; i++)
		{
			printf("'%s' ", result[i]);
		}
		printf("\n");
		free_split(result);
	}
	// Test case 4: 문자열이 모두 구분자로만 구성된 경우
	result = ft_split(",,,,,", ',');
	if (result != NULL)
	{
		printf("Test 4: ");
		for (int i = 0; result[i] != NULL; i++)
		{
			printf("'%s' ", result[i]);
		}
		printf("\n");
		free_split(result);
	}
	// Test case 5: 빈 문자열을 입력한 경우
	result = ft_split("", ',');
	if (result != NULL)
	{
		printf("Test 5: ");
		for (int i = 0; result[i] != NULL; i++)
		{
			printf("'%s' ", result[i]);
		}
		printf("\n");
		free_split(result);
	}
	return (0);
}

split함수는 문자열 하나와 구분자를 입력받아서 문자열을 구분자로 분리하여 2차원 문자열 배열로 반환하는 함수이다.

문자열에 존재하는 단어(set으로 구분된다.)의 길이를 파악한다.
앞서 공부한 split과 다르게 화이트 스페이스를 따지지 않고 구분자를 기준으로 생각한다.
동적할당이 제대로 이루어져야 하기 때문에 크기에 맞게 동적할당한다.

내부 함수가 많이 필요하니 static선언하거나 함수를 추가하여 사용할 것

ft_itoa

int	ft_ilen(int n)
{
	int	i;

	i = 0;
	if (n == 0)
		i = 1;
	else if (n < 0)
	{
		i = 1;
		while (n)
		{
			n = n / 10;
			i++;
		}
	}
	else if (n > 0)
	{
		while (n)
		{
			n = n / 10;
			i++;
		}
	}
	return (i);
}

char	*ft_itoa(int n)
{
	int				size_n;
	unsigned int	fn;
	char			*ia;

	size_n = ft_ilen(n);
	ia = (char *)malloc(sizeof(char) * size_n + 1);
	if (ia == NULL)
		return (0);
	ia[size_n] = '\0';
	if (n < 0)
	{
		ia[0] = '-';
		fn = n * (-1);
	}
	else
		fn = n;
	while (fn)
	{
		ia[size_n - 1] = (fn % 10) + '0';
		fn = fn / 10;
		size_n--;
	}
	if (n == 0)
		ia[0] = '0';
	return (ia);
}

int	main(void)
{
	char *result;

	// Test case 1: 양수
	result = ft_itoa(12345);
	if (result != NULL)
	{
		printf("Test 1: %s\n", result); // 기대 결과: "12345"
		free(result);
	}

	// Test case 2: 음수
	result = ft_itoa(-12345);
	if (result != NULL)
	{
		printf("Test 2: %s\n", result); // 기대 결과: "-12345"
		free(result);
	}

	// Test case 3: 0인 경우
	result = ft_itoa(0);
	if (result != NULL)
	{
		printf("Test 3: %s\n", result); // 기대 결과: "0"
		free(result);
	}

	// Test case 4: 큰 양수
	result = ft_itoa(2147483647);
	if (result != NULL)
	{
		printf("Test 4: %s\n", result); // 기대 결과: "2147483647"
		free(result);
	}

	// Test case 5: 큰 음수
	result = ft_itoa(-2147483648);
	if (result != NULL)
	{
		printf("Test 5: %s\n", result); // 기대 결과: "-2147483648"
		free(result);
	}

	return (0);
}

itoa함수는 숫자를 문자열로 변환하여 반환해주는 함수이다.

0에 대한 예외 처리와 숫자길이를 구하는 함수가 필요함

ft_strmapi

char	*ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
	size_t	i;
	char	*sc;

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

// 예시 함수들
char	to_upper(unsigned int index, char c)
{
	// 모든 문자를 대문자로 변환
	if (c >= 'a' && c <= 'z')
	{
		return (c - 32);
	}
	return (c);
}

char	add_index(unsigned int index, char c)
{
	// 각 문자에 인덱스 값을 더한 문자로 변환
	return (c + index);
}

char	toggle_case(unsigned int index, char c)
{
	// 인덱스가 짝수면 대문자로, 홀수면 소문자로 변환
	if (index % 2 == 0)
	{
		if (c >= 'a' && c <= 'z')
		{
			return (c - 32);
		}
	}
	else
	{
		if (c >= 'A' && c <= 'Z')
		{
			return (c + 32);
		}
	}
	return (c);
}

// 테스트 코드
int	main(void)
{
	char	*result;

	// Test case 1: 모든 문자를 대문자로 변환
	result = ft_strmapi("hello world", to_upper);
	if (result != NULL)
	{
		printf("Test 1: %s\n", result); // 기대 결과: "HELLO WORLD"
		free(result);
	}
	// Test case 2: 각 문자에 인덱스 값을 더한 문자로 변환
	result = ft_strmapi("abcde", add_index);
	if (result != NULL)
	{
		printf("Test 2: %s\n", result); // 기대 결과: "acegi"
		free(result);
	}
	// Test case 3: 인덱스가 짝수면 대문자, 홀수면 소문자로 변환
	result = ft_strmapi("HeLLo WoRLd", toggle_case);
	if (result != NULL)
	{
		printf("Test 3: %s\n", result); // 기대 결과: "HELlO WoRLd"
		free(result);
	}
	// Test case 4: 빈 문자열
	result = ft_strmapi("", to_upper);
	if (result != NULL)
	{
		printf("Test 4: '%s'\n", result); // 기대 결과: ''
		free(result);
	}
	// Test case 5: NULL 입력
	result = ft_strmapi(NULL, to_upper);
	if (result == NULL)
	{
		printf("Test 5: NULL result (expected)\n"); // 기대 결과: NULL 출력
	}
	return (0);
}

원본 문자열에서 함수f를 적용하여 생성한 문자열 반환하는 함수

문자열 s를 순회하며 함수’f’를 적용하고 새로운 문자열을 생성한다.
null처리 중요

ft_striteri

void	ft_striteri(char *s, void (*f)(unsigned int, char *))
{
	size_t	i;
	size_t	len;

	if (s == 0)
		return ;
	len = ft_strlen(s);
	i = 0;
	while (i < len)
	{
		f(i, &s[i]);
		i++;
	}
}

// 예시 함수들
void	to_upper(unsigned int index, char *c)
{
	// 각 문자를 대문자로 변환
	if (*c >= 'a' && *c <= 'z')
	{
		*c = *c - 32;
	}
}

void	add_index(unsigned int index, char *c)
{
	// 각 문자에 인덱스 값을 더함
	*c = *c + index;
}

void	toggle_case(unsigned int index, char *c)
{
	// 인덱스가 짝수면 대문자, 홀수면 소문자로 변환
	if (index % 2 == 0 && *c >= 'a' && *c <= 'z')
	{
		*c = *c - 32; // 대문자로 변환
	}
	else if (index % 2 != 0 && *c >= 'A' && *c <= 'Z')
	{
		*c = *c + 32; // 소문자로 변환
	}
}

// 테스트 코드
int	main(void)
{
	char	str1[] = "hello world";
	char	str2[] = "abcde";
	char	str3[] = "HeLLo WoRLd";

	// Test case 1: 모든 문자를 대문자로 변환
	ft_striteri(str1, to_upper);
	printf("Test 1: %s\n", str1); // 기대 결과: "HELLO WORLD"
	// Test case 2: 각 문자에 인덱스 값을 더함
	ft_striteri(str2, add_index);
	printf("Test 2: %s\n", str2); // 기대 결과: "acegi"
	// Test case 3: 인덱스가 짝수면 대문자, 홀수면 소문자로 변환
	ft_striteri(str3, toggle_case);
	printf("Test 3: %s\n", str3); // 기대 결과: "HELlO WoRLd"
	return (0);
}

striteri함수는 문자열을 순회하며 함수 f를 적용사키는 함수이다.

순회하면서 적용시키는데 가변 함수 f인자값이 (char *)인 이유는 반환값이 void이며 주소값을 전달하여 함수에서 직접 함수를 적용할 수 있도록 포인터로 주소를 넘겨준다.

fd 0 표준 입력

1 표준 출력

2 표준 에러

ft_putchar_fd

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

putchar_fd함수는 해당하는 fd(파일디스크립터 값)으로 열려있는 스트림에 바이트열을 c문자를 흘려보내는 함수이다.

ft_putstr_fd

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

putstr_fd함수는 해당하는 fd(파일디스크립터 값)으로 열려있는 스트림에 바이트열을 문자열 s를 흘려보내는 함수이다.

ft_putendl_fd

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

putendl_fd함수는 putstr_fd함수에서 줄바꿈(‘\n’)을 추가한 함수이다.

ft_putnbr_fd

void	ft_putnbr_fd(int n, int fd)
{
	if (n == -2147483648)
		ft_putstr_fd("-2147483648", fd);
	else if (n >= 0 && n <= 9)
		ft_putchar_fd(n + '0', fd);
	else if (n > 0)
	{
		ft_putnbr_fd(n / 10, fd);
		ft_putchar_fd(n % 10 + '0', fd);
	}
	else if (n < 0)
	{
		ft_putchar_fd('-', fd);
		ft_putnbr_fd(-n, fd);
	}
}

putnbr_fd함수는 똑같은 방식으로 숫자로 바꾸서 스트림에 흘려보낸다.

Bonus part

ft_lstnew

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

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

int	main(void)
{
	t_list	*node1;
	t_list	*node2;
	t_list	*node3;
	int		value1;
	char	*str;

	// Test case 1: 정수를 content로 가지는 노드 생성
	value1 = 42;
	node1 = ft_lstnew(&value1);
	if (node1 != NULL)
	{
		printf("Test 1: Node content (int) = %d\n", *(int *)node1->content);
		// 기대 결과: 42
		free(node1);
	}
	else
	{
		printf("Test 1: Node creation failed.\n");
	}
	// Test case 2: 문자열을 content로 가지는 노드 생성
	str = "Hello, world!";
	node2 = ft_lstnew(str);
	if (node2 != NULL)
	{
		printf("Test 2: Node content (string) = %s\n", (char *)node2->content);
		// 기대 결과: "Hello, world!"
		free(node2);
	}
	else
	{
		printf("Test 2: Node creation failed.\n");
	}
	// Test case 3: NULL content를 가지는 노드 생성
	node3 = ft_lstnew(NULL);
	if (node3 != NULL)
	{
		printf("Test 3: Node content (NULL) = %s\n",
				(node3->content == NULL ? "NULL" : "Not NULL"));
					// 기대 결과: "NULL"
		free(node3);
	}
	else
	{
		printf("Test 3: Node creation failed.\n");
	}
	return (0);
}

리스트하나를 동적할당하고 content를 넣어준뒤 next를 null을 가리키게 하는 함수이다.

ft_lstadd_front

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

// 연결 리스트를 출력하는 함수
void	print_list(t_list *lst)
{
	t_list	*current;

	current = lst;
	while (current != NULL)
	{
		printf("%s -> ", (char *)current->content);
		current = current->next;
	}
	printf("NULL\n");
}

// 연결 리스트의 모든 노드를 해제하는 함수
void	free_list(t_list *lst)
{
	t_list	*current;
	t_list	*next;

	current = lst;
	while (current != NULL)
	{
		next = current->next;
		free(current);
		current = next;
	}
}

// 테스트 코드
int	main(void)
{
	t_list	*new_node;

	t_list *head = NULL; // 초기 리스트는 비어 있음
	// Test case 1: 빈 리스트에 새 노드 추가
	new_node = ft_lstnew("First Node");
	ft_lstadd_front(&head, new_node);
	printf("Test 1: ");
	print_list(head); // 기대 결과: "First Node -> NULL"
	// Test case 2: 기존 리스트 앞에 새 노드 추가
	new_node = ft_lstnew("New Front Node");
	ft_lstadd_front(&head, new_node);
	printf("Test 2: ");
	print_list(head); // 기대 결과: "New Front Node -> First Node -> NULL"
	// Test case 3: 또 다른 노드 추가
	new_node = ft_lstnew("Another Front Node");
	ft_lstadd_front(&head, new_node);
	printf("Test 3: ");
	print_list(head);
	// 기대 결과: "Another Front Node -> New Front Node -> First Node -> NULL"
	// 메모리 해제
	free_list(head);
	return (0);
}

리스트 head부분에 new를 추가하는 함수이다.

null 체크 후 head부분이기 때문에 *lst로 접근하여 연결한다.

ft_lstsize

int	ft_lstsize(t_list *lst)
{
	t_list	*current;
	int		i;

	current = lst;
	i = 0;
	while (current != NULL)
	{
		i++;
		current = current->next;
	}
	return (i);
}

// 연결 리스트의 모든 노드를 해제하는 함수
void	free_list(t_list *lst)
{
	t_list	*current;
	t_list	*next;

	current = lst;
	while (current != NULL)
	{
		next = current->next;
		free(current);
		current = next;
	}
}

// 테스트 코드
int	main(void)
{
	t_list	*head;
	int		size;

	head = NULL;
	// Test case 1: 빈 리스트의 크기
	size = ft_lstsize(head);
	printf("Test 1: List size = %d (Expected: 0)\n", size);
	// Test case 2: 노드 1개 추가한 리스트의 크기
	ft_lstadd_front(&head, ft_lstnew("First Node"));
	size = ft_lstsize(head);
	printf("Test 2: List size = %d (Expected: 1)\n", size);
	// Test case 3: 노드 2개 추가한 리스트의 크기
	ft_lstadd_front(&head, ft_lstnew("Second Node"));
	size = ft_lstsize(head);
	printf("Test 3: List size = %d (Expected: 2)\n", size);
	// Test case 4: 노드 3개 추가한 리스트의 크기
	ft_lstadd_front(&head, ft_lstnew("Third Node"));
	size = ft_lstsize(head);
	printf("Test 4: List size = %d (Expected: 3)\n", size);
	// 메모리 해제
	free_list(head);
	return (0);
}

리스트의 사이즈를 반환해주는 함수이다. 다시말해서 리스트에 연결된 요소가 몇 개인지 파악한다.

반환값이 int형이기 때문에 while문으로 쉽게 반환이 가능하다.

ft_lstlast

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

// 연결 리스트의 모든 노드를 해제하는 함수
void	free_list(t_list *lst)
{
	t_list	*current;
	t_list	*next;

	current = lst;
	while (current != NULL)
	{
		next = current->next;
		free(current);
		current = next;
	}
}

// 테스트 코드
int	main(void)
{
	t_list *head = NULL;
	t_list *last_node;

	// Test case 1: 빈 리스트의 마지막 노드
	last_node = ft_lstlast(head);
	if (last_node == NULL)
	{
		printf("Test 1: Last node = NULL (Expected: NULL)\n");
	}
	else
	{
		printf("Test 1: Unexpected result. Last node is not NULL.\n");
	}

	// Test case 2: 노드 1개인 리스트의 마지막 노드
	head = ft_lstnew("First Node");
	last_node = ft_lstlast(head);
	if (last_node != NULL)
	{
		printf("Test 2: Last node content = %s (Expected: 'First Node')\n",
			(char *)last_node->content);
	}
	else
	{
		printf("Test 2: Last node is NULL (Unexpected).\n");
	}

	// Test case 3: 노드 3개 추가 후 마지막 노드 찾기
	head = ft_lstnew("Second Node");
	head = ft_lstnew("Third Node");
	last_node = ft_lstlast(head);
	if (last_node != NULL)
	{
		printf("Test 3: Last node content = %s (Expected: 'Third Node')\n",
			(char *)last_node->content);
	}
	else
	{
		printf("Test 3: Last node is NULL (Unexpected).\n");
	}

	// 메모리 해제
	free_list(head);

	return (0);
}

리스트의 마지막요소를 반환하는 함수이다.

ft_lstadd_back

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

	if (lst == 0 || new == 0)
		return ;
	if (*lst == 0)
	{
		*lst = new;
		return ;
	}
	current = *lst;
	while (current->next)
	{
		current = current->next;
	}
	current->next = new;
}

// 연결 리스트를 출력하는 함수
void	print_list(t_list *lst)
{
	t_list	*current;

	current = lst;
	while (current != NULL)
	{
		printf("%s -> ", (char *)current->content);
		current = current->next;
	}
	printf("NULL\n");
}

// 연결 리스트의 모든 노드를 해제하는 함수
void	free_list(t_list *lst)
{
	t_list	*current;
	t_list	*next;

	current = lst;
	while (current != NULL)
	{
		next = current->next;
		free(current);
		current = next;
	}
}

// 테스트 코드
int	main(void)
{
	t_list	*new_node;

	t_list *head = NULL; // 초기 리스트는 비어 있음
	// Test case 1: 빈 리스트에 새 노드 추가
	new_node = ft_lstnew("First Node");
	ft_lstadd_back(&head, new_node);
	printf("Test 1: ");
	print_list(head); // 기대 결과: "First Node -> NULL"
	// Test case 2: 기존 리스트의 끝에 새 노드 추가
	new_node = ft_lstnew("Second Node");
	ft_lstadd_back(&head, new_node);
	printf("Test 2: ");
	print_list(head); // 기대 결과: "First Node -> Second Node -> NULL"
	// Test case 3: 리스트의 끝에 또 다른 새 노드 추가
	new_node = ft_lstnew("Third Node");
	ft_lstadd_back(&head, new_node);
	printf("Test 3: ");
	print_list(head);
	// 기대 결과: "First Node -> Second Node -> Third Node -> NULL"
	// 메모리 해제
	free_list(head);
	return (0);
}

리스트의 가장 마지막 부분 tail에 new를 추가하는 함수이다.

마지막 요소에 접근하는 lstlast를 사용해도 되고 반복문으로 접근해도 된다.
head부분이 null인 경우 예외처리 필요

ft_lstdelone

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

해석 그대로 lst(리스트) del(삭제) one(하나) 즉, 연결리스트중 하나를 지우는 함수이다.

첫 번째 인자값으로 받은 요소를 두번째 인자 함수포인터로 해제하고 메모리 자체도 해제한다.

next 다음을 가리키는 포인터는 해제하면 안된다.

ft_lstclear

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

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

인자값으로 받은 리스트에 접근하여 리스트의 모든 content를 삭제하고 해제한다.

연산자 우선순위 주의하기
댕글링 포인터 초기화 필수

ft_lstiter

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

lst를 순회하며 모든 content요소에 함수 f()를 적용시키는 함수이다.

같은 맥락으로 반복적으로 순회하며 요소에 접근한다. size함수와 같음

ft_lstmap

t_list	*ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
	t_list	*newnode;
	t_list	*node;

	node = 0;
	while (lst)
	{
		newnode = ft_lstnew((*f)(lst->content));
		if (newnode == 0)
		{
			ft_lstclear(&node, del);
			return (0);
		}
		ft_lstadd_back(&node, newnode);
		lst = lst->next;
	}
	return (node);
}

인자인 lst리스트의 content값을 함수 f()적용시켜서 새로운 리스트를 반환하는 함수이다.

지금까지 만들어진 lst함수들을 활용하여 풀이한다.

#ifndef LIBFT_H
# define LIBFT_H

# include <stdlib.h>
# include <unistd.h>

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

int					ft_isalpha(int c);
int					ft_isdigit(int c);
int					ft_isalnum(int c);
int					ft_isascii(int c);
int					ft_isprint(int c);

int					ft_toupper(int c);
int					ft_tolower(int c);

size_t				ft_strlen(const char *s);
size_t				ft_strlcpy(char *dst, const char *src, size_t size);
size_t				ft_strlcat(char *dst, const char *src, size_t size);
char				*ft_strchr(const char *s, int c);
char				*ft_strrchr(const char *s, int c);
int					ft_strncmp(const char *s1, const char *s2, size_t n);
char				*ft_strnstr(const char *big, const char *little,
						size_t len);
char				*ft_strdup(const char *s);
char				*ft_strjoin(char const *s1, char const *s2);
char				*ft_strmapi(char const *s, char (*f)(unsigned int, char));
char				*ft_strtrim(char const *s1, char const *set);
char				**ft_split(char const *s, char c);
char				*ft_substr(char const *s, unsigned int start, size_t len);
void				ft_striteri(char *s, void (*f)(unsigned int, char *));

void				ft_putchar_fd(char c, int fd);
void				ft_putstr_fd(char *s, int fd);
void				ft_putendl_fd(char *s, int fd);
void				ft_putnbr_fd(int n, int fd);

void				*ft_memset(void *s, int c, size_t n);
void				*ft_memcpy(void *dest, const void *src, size_t n);
void				*ft_memmove(void *dest, const void *src, size_t n);
void				*ft_memchr(const void *s, int c, size_t n);
int					ft_memcmp(const void *s1, const void *s2, size_t n);

void				ft_bzero(void *s, size_t n);

int					ft_atoi(const char *nptr);
char				*ft_itoa(int n);

void				*ft_calloc(size_t nmemb, size_t size);

t_list				*ft_lstnew(void *content);
void				ft_lstadd_front(t_list **lst, t_list *new);
int					ft_lstsize(t_list *lst);
t_list				*ft_lstlast(t_list *lst);
void				ft_lstadd_back(t_list **lst, t_list *new);
void				ft_lstdelone(t_list *lst, void (*del)(void *));
void				ft_lstclear(t_list **lst, void (*del)(void *));
void				ft_lstiter(t_list *lst, void (*f)(void *));
t_list				*ft_lstmap(t_list *lst, void *(*f)(void *),
						void (*del)(void *));
#endif

NAME = libft.a

SRCS = ft_isalpha.c ft_isdigit.c ft_isalnum.c ft_isascii.c \
        ft_isprint.c ft_strlen.c ft_memset.c ft_bzero.c ft_memcpy.c \
        ft_memmove.c ft_strlcpy.c ft_strlcat.c ft_toupper.c ft_tolower.c \
        ft_strchr.c ft_strrchr.c ft_strncmp.c ft_memchr.c ft_memcmp.c \
        ft_strnstr.c ft_atoi.c ft_calloc.c ft_strdup.c ft_substr.c \
        ft_strjoin.c ft_strtrim.c ft_split.c ft_itoa.c ft_strmapi.c \
        ft_striteri.c ft_putchar_fd.c ft_putstr_fd.c ft_putendl_fd.c ft_putnbr_fd.c

BNS_SRCS = ft_lstnew_bonus.c ft_lstsize_bonus.c ft_lstadd_back_bonus.c ft_lstadd_front_bonus.c \
           ft_lstclear_bonus.c ft_lstdelone_bonus.c ft_lstiter_bonus.c ft_lstlast_bonus.c ft_lstmap_bonus.c

OBJS = $(SRCS:%.c=%.o)

BONUS_OBJS = $(BNS_SRCS:%.c=%.o)

CFLAGS = -Wall -Wextra -Werror -I.

ifdef WITH_BONUS
    OBJ_FILE = $(OBJS) $(BONUS_OBJS)
else
    OBJ_FILE = $(OBJS)
endif

all: $(NAME)
$(NAME): $(OBJ_FILE)
	ar -rcs $@ $^
%.o: %.c
	cc $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) $(BONUS_OBJS)

fclean:
	make clean
	rm -f $(NAME) 

re: 
	make fclean
	make all

bonus: $(OBJ_FILE)
	@make WITH_BONUS=1 all

.PHONY : all clean fclean re bonus

libft - KimTaebin-ai/study_posts GitHub Wiki

필요 개념 및 학습 내용

libft

Part1

isalpha

isdigit

isalnum

isascii

isprint

strlen

memset

bzero

memcpy

memmove

strlcpy

strlcat

toupper

tolower

strchr

strrchr

strncmp

memchr

memcmp

strnstr

atoi

calloc

strdup

Part2

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

Bonus part

ft_lstnew

ft_lstadd_front

ft_lstsize

ft_lstlast

ft_lstadd_back

ft_lstdelone

ft_lstclear

ft_lstiter

ft_lstmap

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️