[42서울 / Libft] Libft 정리

Hans Park·2021년 6월 29일
42Seoul42본과정42서울Ecole 42Libftft_libftft_split본과정에꼴42카뎃

42서울 본과정

목록 보기
1/15
post-thumbnail

Born to Code

42서울 본과정
금방 할 수 있는 것은 제외했습니다.

토글이 없어 보기 힘듭니다.
노션과 깃 페이지를 남겨두니 참고하세요.

노션
깃

Hits

libftpedia 참고

🚀 memset

#include <string.h>

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

  • 구현 코드

    void	*ft_memset(void *p, int c, size_t len)
{
	size_t	i;
	char	*ptr;

	i = 0;
	ptr = (char *)p;
	while (i < len)
	{
		ptr[i] = (unsigned char)c;
		i++;
	}
	return ((void*)ptr);
}

✔️ Description

  • The memset() function writes len bytes of value c (converted to an unsigned char) to the
    string b.
  • memset()함수는 b 가 가리키는 메모리 주소부터 len 바이트만큼 c값을 채운다.
  • 이때, int로 받는 c는 함수 내부에서 unsigned char로 자동 변경된다.

✔️ Note

  • unsigned char는 모든 bit를 투명하게 볼 수 있다. (부호비트가 없기 때문)
  • 따라서, 임의의 메모리에 바이트 단위로 접근해 값을 다룰 때, 반드시 unsigned char를 사용한다.
  • 0, -1, 0x3F, 0x7F를 제외한 나머지 값은 원하는 값으로 초기화할 수 없다.

✔️ Return

성공 시 첫번째 인자로 들어간 ptr을 반환, 실패 시 NULL을 반환한다.

⁉️ Notice

  • memset()과 bzero() 모두 unsigned char로 캐스팅하는 과정이 있다.
  • 1바이트 변수를 제외한 변수를 초기화 할 시, 0이외의 값으로 초기화 안됨.
int n;
memset(&n, 1, sizeof(int));
//n = [00000001000000010000000100000001] = 16843009
  • new, malloc 등 동적 배열 생성하는 변수가 있는 struct, class는 memset으로 초기화 안됨.
    사용 시, 각각 분리하여 초기화.
struct A 
{
   int i;
   char* c;
};
  
void main()
{
   A a;
   a.c = new char[100];
   memset(&a, 0, sizeof(A));
   if(a.c != NULL) 
   {
      delete[] a.c;
      a.c = NULL;
   }
}
/*여기서 sizeof(A)는 struct member alignment가 어떤 값이든
 4(int i) + 4(char* c, address는 4) = 8Bytes.
그러므로 위의 소스는 동적으로 생성한 변수는 초기화가 되지 못하고, 
char* c가 NULL로 초기화가 됨으로써, 
이전에 생성한 메모리는 메모리 누수가 발생.*/

//사용 시 분리하여 초기화
a.i = 0;
memset(a.c, 0, sizeof(char)*100);


# 🚀 bzero

---

```c
#include <string.h>

 void
 bzero(void *s, size_t n);

  • 구현 코드

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

	ptr = (char *)p;
	i = 0;
	while (i < n)
	{
		ptr[i] = 0;
		i++;
	}
	return ;
}

✔️ Description

  • The bzero() function writes n zeroed bytes to the string s. If n is zero, bzero() does
    nothing.
  • bzero()함수는 s가 가리키는 메모리로부터 n바이트만큼 0값을 채운다.

✔️ Return

none

⁉️ Notice

  • memset()과 bzero() 모두 unsigned char로 캐스팅하는 과정이 있다.

🚀 memcpy

#include <string.h>

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

❗42에서 restrict 사용 불가

  • 구현 코드

    void	*ft_memcpy(void *dest, const void *src, size_t n)
{
	char		*temp_dest;
	const char	*temp_src;
	size_t		i;

	i = 0;
	temp_dest = (char *)dest;
	temp_src = (const char *)src;
	while (i < n)
	{
		temp_dest[i] = temp_src[i];
		i++;
	}
	return (dest);
}

✔️ Restrict?

  • restrict 포인터는 메모리 접근에 관련된 최적화 기능 (C99 표준).
  • 포인터가 하나만 가리키고 있다는 것을 컴파일러가 알면, 메모리 복사 없이 비트연산자를 이용해 연산한다.
  • 알맞은 조건이 적용되면, 성능이 비약적으로 증가한다.

✔️ Description

  • The memcpy() function copies n bytes from memory area src to memory area dst. If dst and
    src overlap, behavior is undefined. Applications in which dst and src might overlap should
    use memmove(3) instead.
  • memcpy()함수는 src가 가리키는 메모리 주소로부터 n바이트 크기(길이)만큼 dst메모리에 복사한다.

✔️ Return

dst를 반환한다.

⁉️ Notice

  • 사용 시, 메모리 영역은 겹치면 안된다.
    곂친다면, memmove()함수를 사용해야 한다.

🚀 memccpy

#include <string.h>

void *
memccpy(void *restrict dst, const void *restrict src, int c, size_t n);

❗42에서 restrict 사용 불가

  • 구현 코드

    void	*ft_memccpy(void *dst, const void *src, int c, size_t n)
{
	unsigned char		*temp_dest;
	const unsigned char	*temp_src;
	size_t				i;

	i = 0;
	temp_dest = (unsigned char *)dest;
	temp_src = (const unsigned char *)src;
	while (i < n)
	{
		temp_dest[i] = temp_src[i];
		if (temp_dest[i] == (unsigned char)c)
			return (temp_dest + i + 1);
		i++;
	}
	return (0);
}

✔️ Description

  • The memccpy() function copies bytes from string src to string dst. If the character c (as converted to an unsigned char) occurs in the string src, the copy stops and a pointer to the
    byte after the copy of c in the string dst is returned. Otherwise, n bytes are copied, and
    a NULL pointer is returned.
  • memccpy()함수는 src가 가리키는 메모리 주소로부터 n바이트 크기(길이)만큼 dst메모리에 복사한다. 단, 문자 c를 만나게 되면 c까지 복사하고 중단한다.

✔️ Return

dest에서 c의 다음 위치 (복사가 끝난 다음 메모리주소)를 리턴한다. c를 만나지 않는다면 n만큼 복사하고 NULL을 반환한다.

⁉️ Notice

  • c를 1바이트 크기가 아닌 자료형을 사용하여 찾을 경우, 문제가 생긴다.
    memccpy함수는 1바이트 메모리만 비교하여 찾기 때문이다.
    굳이 int형을 다뤄야 한다면, 1 ~ 255 범위 내 사용하는 것이 좋다.
#include <stdio.h>
#include <string.h>

int main(void)
{
	int word1[20] = { 0, };
	int temp[] = {4423, 2, 3, 65281, 4};
	int *result

	result = memccpy(word1, temp, 65281, sizeof(temp));
	if (result == 0)
		printf("ss\n");
	for (int i = 0; i < 5; i++)
		printf("%d ", word1[i]);
	printf("\n");
}
/*---출력---*/
5 2 3 1 0

🚀 memmove

#include <string.h>

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

  • 구현 코드

    void	*ft_memmove(void *dst, const void *src, size_t len)
{
	unsigned char		*temp_dest;
	const unsigned char	*temp_src;

	temp_dest = (unsigned char *)dst;
	temp_src = (const unsigned char *)src;
	if (temp_dest <= temp_src)
		while (len--)
			*(temp_dest++) = *(temp_src++);
	else
	{
		temp_dest += (len - 1);
		temp_src += (len - 1);
		while (len--)
			*temp_dest-- = *temp_src--;
	}
	return (dst);
}

✔️ Description

  • The memmove() function copies len bytes from string src to string dst. The two strings may
    overlap; the copy is always done in a non-destructive manner.
  • memmove()함수는 len바이트만큼 src 메모리에서 dest로 복사한다.
  • 복사는 항상 비파괴 방식으로 진행된다.
  • 즉, src배열은 src와 dest메모리 영역과 겹치지 않는 메모리 영역부터 먼저 복사한다.
  • src 주소가 dest보다 크다면, 순차적으로 데이터를 복사하면 된다.
    src 주소가 dest보다 작다면, src 마지막 바이트부터 dest + len에 복사한다.

✔️ Return

dest 반환.

⁉️ Notice

  • 한 배열 안에서 복사를 수행하거나, src 시작주소가 dest 시작 주소보다 앞에 있으면서 두 주소 차이가 len보다 작으면 발생한다.

🚀 memchr

#include <string.h>

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

  • 구현 코드

    void	*ft_memchr(const void *p, int c, size_t n)
{
	const unsigned char	*ptr;
	unsigned char		value;

	ptr = (const unsigned char *)p;
	value = (unsigned char)c;
	while (n--)
	{
		if (*ptr == value)
			return ((void *)ptr);
		ptr++;
	}
	return (0);
}

✔️ Description

  • The memchr() function locates the first occurrence of c (converted to an unsigned char) in
    string s.
  • memchr()함수는 s가 가리키는 메모리 주소로부터 n바이트 중 처음으로 c와 일치하는 값의 주소를 리턴한다.

✔️ Return

c와 일치하는 값의 주소를 리턴한다. 찾지 못하면 NULL을 반환한다.

⁉️ Notice

🚀 memcmp

#include <string.h>

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

  • 구현 코드

    int		ft_memcmp(const void *s1, const void *s2, size_t n)
{
	const unsigned char	*ptr1;
	const unsigned char *ptr2;

	ptr1 = (const unsigned char *)s1;
	ptr2 = (const unsigned char *)s2;
	while (n--)
	{
		if (*ptr1 != *ptr2)
			return (*ptr1 - *ptr2);
		ptr1++;
		ptr2++;
	}
	return (0);
}

✔️ Description

  • The memcmp() function compares byte string s1 against byte string s2. Both strings are
    assumed to be n bytes long.
  • s1이 가리키는 n바이트만큼의 데이터와 s2가 가리키는 n 바이트만큼의 데이터를 비교하여, 같으면 0을 리턴하고 다르면 0이 아닌 값을 리턴한다.

✔️ Return

위 기재

⁉️ Notice

  • 함수 사용 시 오버플로우에 주의. (n은 버퍼보다 작거나 같게)
  • strcmp와 차이점은, 두 문자열 중 하나가 끝나더라도 서로 다른 값이 나오거나 n개가 될 때까지 비교한다.
    따라서, s1, s2 모두 NULL값이 나오면 남은 카운트 관계 없이 0을 반환한 strcmp와 차이가 있다.

🚀 strlen

🚀 strlcpy

#include <string.h>

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

  • 구현 코드

    size_t	ft_strlcpy(char *dst, char *src, size_t dstsize)
{
	size_t	i;

	i = 0;
	while (i + 1 < size && src[i] != '\0')
	{
		dest[i] = src[i];
		i++;
	}
	dest[i] = '\0';
	while (src[i] != '\0')
		i++;
	return (i);
}

✔️ Description

  • The strlcpy() and strlcat() functions copy and concatenate strings with the same input
    parameters and output result as snprintf(3). They are designed to be safer, more consis-
    tent, and less error prone replacements for the easily misused functions strncpy(3) and
    strncat(3).
  • strlcpy() and strlcat() take the full size of the destination buffer and guarantee NUL-ter-
    mination if there is room. Note that room for the NUL should be included in dstsize.
  • strlcpy() copies up to dstsize - 1 characters from the string src to dst, NUL-terminating
    the result if dstsize is not 0.
  • strlcpy() 함수는 실수하지 않도록 디자인되었다.
  • dstsize가 0이 아닌 경우 dstsize - 1만큼 문자를 src에서 dst로 복사 후 null을 포함하여 종료한다.

✔️ Return

⁉️ Notice

🚀 strlen

🚀 strchr

#include <string.h>

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

  • 구현 코드

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

✔️ Description

  • The strchr() function locates the first occurrence of c (converted to a char) in the string
    pointed to by s. The terminating null character is considered to be part of the string;
    therefore if c is \0', the functions locate the terminating\0'.
  • strchr() 함수는 s에서 c문자가 가장 먼저 나타나는 곳을 찾는다.

✔️ Return

c의 주소를 리턴한다. 찾는 문자가 s안에 없다면 NULL포인터를 리턴한다.

⁉️ Notice

🚀 strrchr

🚀 strnstr

#include <string.h>

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

  • 구현 코드

✔️ Description

  • The strnstr() function locates the first occurrence of the null-terminated string needle in
    the string haystack, where not more than len characters are searched. Characters that
    appear after a `\0' character are not searched. Since the strnstr() function is a FreeBSD
    specific API, it should only be used when portability is not a concern.
  • 문자열 내에서 부분문자열을 탐색하는 함수이다.

✔️ Return

needle이 처음 나타나는 주소를 리턴한다. 만약 없다면 NULL을 리턴한다.

⁉️ Notice

🚀 strncmp

🚀 atoi

  • 구현 코드

    int		ft_atoi(const char *str)
{
	unsigned long long	answer;
	unsigned long long	max;
	int					flag;

	answer = 0;
	flag = 1;
	max = 9223372036854775807;
	while ((*str >= 9 && *str <= 13) || *str == ' ')
		str++;
	if (*str == '+' || *str == '-')
	{
		if (*str == '-')
			flag *= -1;
		str++;
	}
	while (ft_isdigit(*str))
	{
		answer = (answer * 10) + (*str - '0');
		if (flag == 1 && answer > max)
			return (-1);
		if (flag == -1 && answer > max + 1)
			return (0);
		str++;
	}
	return (answer * flag);
}

⁉️ Notice

  • atoi함수는 long long max 보다 큰 오버플로우 시 -1, long long min 보다 작은 언더플로우 시 0이 반환된다.

🚀 isalpha

🚀 isdigit

🚀 isalnum

🚀 isascii

🚀 isprint

🚀 toupper

🚀 tolower

🚀 calloc

#include <stdlib.h>

void *
calloc(size_t count, size_t size);

  • 구현 코드

    void	*ft_calloc(size_t count, size_t size)
{
	void	*ptr;

	ptr = malloc(count + size);
	if (!ptr)
		return (0);
	ft_bzero(ptr, count * size);
	return (ptr);
}

✔️ Description

  • The calloc() function contiguously allocates enough space for count
    objects that are size bytes of memory each and returns a pointer to
    the allocated memory. The allocated memory is filled with bytes of
    value zero.
  • calloc()함수는 malloc()함수와 마찬가지로 size크기(바이트)의 count개수만큼 바이트를 할당한다.
  • malloc과 달리 전부 0으로 초기화한다.

✔️ Return

할당된 메모리 주소를 반환한다.

⁉️ Notice

🚀 strdup

#include <string.h>

void	*ft_calloc(size_t count, size_t size)

  • 구현 코드

    void	*ft_calloc(size_t count, size_t size)
{
	void	*ptr;

	ptr = malloc(count + size);
	if (!ptr)
		return (0);
	ft_bzero(ptr, count * size);
	return (ptr);
}

✔️ Description

  • The strdup() function allocates sufficient memory for a copy of the string s1, does the copy, and returns a pointer to it. The pointer may subsequently be used as an argument to the function free(3). If insufficient memory is available, NULL is returned and errno is set to ENOMEM.
  • strdup()함수는 s1이 복사되어 충분히 들어갈만한 공간을 확보하고, 문자열을 복사한다.
  • 공간은 str길이 + 1 만큼 확보되어야 한다.

✔️ Return

복사된 문자열의 주소를 반환한다. 에러 발생시 NULL을 반환한다.

⁉️ Notice

  • 함수 사용 시, free 함수 등으로 메모리 해제를 하여야 한다.

🚀 ft_substr

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

  • 구현 코드

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

	if (!s)
		return (0);
	if (ft_strlen(s) < start)
		return (ft_strdup(""));
	if (len > ft_strlen(s))
		l = ft_strlen(s);
	else
		l = len;
	ptr = (char *)malloc(sizeof(char) * (l + 1));
	if (!ptr)
		return (0);
	if (l == 0)
		ptr[0] = 0;
	else
		ft_strlcpy(ptr, (char *)(s + start), l + 1);
	return (ptr);
}

✔️ Description

  • Allocates (with malloc(3)) and returns a substring from the string s.
    The substring begins at index start and is of maximum size len
  • 문자열[start] 에서부터 len만큼의 길이만큼 하위문자열을 복제하여 반환한다.

✔️ Return

하위문자열을 반환한다.

문자열의 길이보다 start 값이 클 경우 빈 문자열을 반환한다.

복사할 문자열의 길이가 len보다 짧으면 그만큼만 복사 후 반환한다. (문자열 할당 길이는 변동 x)

⁉️ Notice

🚀 ft_strjoin

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

  • 구현 코드

    char	*ft_strjoin(char const *s1, char const *s2)
{
	size_t	s1_len;
	size_t	s2_len;
	char	*ptr;

	if (!s1 && !s2)
		return (0);
	if (!s1)
		return (ft_strdup(s2));
	else if (!s2)
		return (ft_strdup(s1));
	s1_len = ft_strlen(s1);
	s2_len = ft_strlen(s2);
	if (!(ptr = (char *)malloc(sizeof(char) * (s1_len + s2_len + 1))))
		return (0);
	ft_memcpy(ptr, s1, s1_len);
	ft_strlcpy(ptr + s1_len, (char *)s2, s2_len + 1);
	return (ptr);
}

✔️ Description

  • Allocates (with malloc(3)) and returns a new string, which is the result of the concatenation of ’s1’ and ’s2’.
  • 새로운 공간을 할당하여 s1, s2를 연결한 문자열을 저장한 뒤 반환한다.

✔️ Return

s1과 s2를 연결한 새로운 문자열을 반환한다.

⁉️ Notice

  • s1, s2 전부 널이면 0을 반환한다.
  • 하나만 널일경우 나머지 문자열만 복제하여 반환한다.

🚀 ft_strtrim

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

  • 구현 코드

    char	*ft_strtrim(char const *s1, char const *set)
{
	char	*start_ptr;
	char	*end_ptr;
	char	*answer;

	if (!s1)
		return (0);
	if (!set)
		return (ft_strdup(s1));
	start_ptr = (char *)s1;
	while (*start_ptr && ft_strchr(set, *start_ptr))
		start_ptr++;
	if (!(*start_ptr))
		return (ft_strdup(""));
	end_ptr = (char *)s1;
	while (*end_ptr)
		end_ptr++;
	end_ptr--;
	while (start_ptr < end_ptr && ft_strchr(set, *end_ptr))
		end_ptr--;
	if (start_ptr >= end_ptr)
		return (ft_strdup(""));
	if (!(answer = (char *)malloc((end_ptr - start_ptr + 1) + 1)))
		return (0);
	ft_strlcpy(answer, start_ptr, (end_ptr - start_ptr + 1) + 1);
	return (answer);
}

✔️ Description

  • Allocates (with malloc(3)) and returns a copy of ’s1’ with the characters specified in ’set’ removed from the beginning and the end of the string.
  • s1에서 문자열의 시작과 끝에서 set에 지정된 문자들을 제거한 문자열을 새로 복제하여 반환한다.

✔️ Return

위 참고

⁉️ Notice

  • s1이 널이면 0을 반환한다.
  • set이 널이면 s1을 복제하여 반환한다.
  • 문자열 전체가 아님을 유의한다.

🚀 ft_split

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

  • 구현 코드

    static size_t	get_strs_size(char const *s, char c)
{
	size_t		size;
	int			flag;

	size = 1;
	flag = 0;
	while (*s)
	{
		if (*s != c)
			break ;
		s++;
	}
	while (*s)
	{
		if (*s == c)
		{
			if (*(s + 1) != c && *(s + 1) != 0)
				size++;
		}
		s++;
	}
	return (size);
}

static void		set_all_memory_null(char **strs, size_t index)
{
	size_t	i;

	i = 0;
	while (i < index)
		free(strs[i++]);
	free(strs);
	return ;
}

char			**ft_split(char const *s, char c)
{
	char	**strs;
	char	*patrol;
	size_t	index;

	index = 0;
	if (!(strs = (char **)malloc(sizeof(char *) * (get_strs_size(s, c) + 1))))
		return (0);
	while (*s)
		if (*s != c)
		{
			patrol = (char *)s;
			while (*patrol && *patrol != c)
				patrol++;
			if (!(strs[index] = (char *)malloc(patrol - s + 1)))
			{
				set_all_memory_null(strs, index - 1);
				return (0);
			}
			ft_strlcpy(strs[index++], (char *)s, patrol - s + 1);
			s = patrol;
		}
		else
			s++;
	strs[index] = 0;
	return (strs);
}

✔️ Description

  • Allocates (with malloc(3)) and returns an array of strings obtained by splitting ’s’ using the character ’c’ as a delimiter. The array must be ended by a NULL pointer.
  • 구분문자 c를 활용하여, s문자열을 분할하고 이차원 배열에 저장하여 반환한다. 이때 배열은 null로 끝나야 한다.

✔️ Return

맨 끝에 null이 들어간 이차원 배열.

⁉️ Notice

  • 이차원배열의 개념이 어렵다면, 문자열이 나열된 배열이라 생각하자.
  • libft에서 가장 오래 걸리는 문제들 중 하나임을 유의하자.

🚀 ft_itoa

char		*ft_itoa(int n)

  • 구현 코드

    static int	get_number_digits(int n)
{
	int		answer;

	answer = 0;
	if (n <= 0)
		answer++;
	while (n)
	{
		answer++;
		n = n / 10;
	}
	return (answer);
}

static int	get_abs_num(int num)
{
	if (num < 0)
		return (num * -1);
	return (num);
}

char		*ft_itoa(int n)
{
	int		len;
	int		minus_flag;
	char	*result;

	minus_flag = 1;
	if (n < 0)
		minus_flag *= -1;
	len = get_number_digits(n);
	if (!(result = (char *)malloc(len + 1)))
		return (0);
	result[len--] = 0;
	while (len >= 0)
	{
		result[len] = get_abs_num(n % 10) + '0';
		n = n / 10;
		len--;
	}
	if (minus_flag == -1)
		result[0] = '-';
	return (result);
}

✔️ Description

  • Allocates (with malloc(3)) and returns a string representing the integer received as an argument. Negative numbers must be handled.
  • 인수로 받은 정수를 문자열로 치환하여 반환한다. 음수가 고려되어야 한다.

✔️ Return

문자열

⁉️ Notice

🚀 ft_strmapi

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

  • 구현 코드

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

	if (!s || !f)
		return (0);
	len = ft_strlen(s);
	i = 0;
	if (!(result = (char *)malloc(sizeof(char) * len + 1)))
		return (0);
	while (s[i])
	{
		result[i] = f(i, s[i]);
		i++;
	}
	result[i] = 0;
	return (result);
}

✔️ Description

  • Allocates (with malloc(3)) and returns a string representing the integer received as an argument. Negative numbers must be handled.
  • 문자열 s를 복제하는데, 내부 데이터를 문자열 s의 각 데이터를 f에 넣어 받은 값으로 채운다.
    s[0] ⇒ t[f(s[0])]

✔️ Return

복제된 문자열

⁉️ Notice

  • 함수포인터에 대해 알아보자.

🚀 ft_putchar_fd

void	ft_putchar_fd(char c, int fd)

  • 구현 코드

    void	ft_putchar_fd(char c, int fd)
{
	if (fd < 0)
		return ;
	write(fd, &c, 1);
}

✔️ Description

  • Outputs the character ’c’ to the given file descriptor.
  • 지정된 파일 설명자에 문자 'c'를 출력한다.

✔️ Return

⁉️ Notice

  • 파일 디스크립터에 대해 알아보자.

🚀 ft_putstr_fd

void	ft_putstr_fd(char *s, int fd)

  • 구현 코드

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

✔️ Description

  • Outputs the string ’s’ to the given file descriptor.
  • 지정된 파일 설명자에 문자열 's'를 출력한다.

✔️ Return

⁉️ Notice

  • 파일 디스크립터에 대해 알아보자.

🚀 ft_putendl_fd

void	ft_putendl_fd(char *s, int fd)

  • 구현 코드

    void	ft_putendl_fd(char *s, int fd)
{
	if (!s || fd < 0)
		return ;
	ft_putstr_fd(s, fd);
	write(fd, "\n", 1);
}

✔️ Description

  • Outputs the string ’s’ to the given file descriptor. followed by a newline.
  • 지정된 파일 설명자에 문자열 's'를 출력하고 마지막에 개행을 추가한다.

✔️ Return

⁉️ Notice

  • 파일 디스크립터에 대해 알아보자.

🚀 ft_putnbr_fd

void		ft_putnbr_fd(int n, int fd)

  • 구현 코드

    static void	print_number(unsigned int num, int fd)
{
	char c;

	if (num <= 0)
		return ;
	print_number(num / 10, fd);
	c = num % 10 + '0';
	write(fd, &c, 1);
}

void		ft_putnbr_fd(int n, int fd)
{
	unsigned int	num;

	if (fd < 0)
		return ;
	if (n < 0)
		write(fd, "-", 1);
	else if (n == 0)
	{
		write(fd, "0", 1);
		return ;
	}
	if (n == -2147483648)
		num = 2147483648;
	else
	{
		if (n < 0)
			n *= -1;
		num = (unsigned int)n;
	}
	print_number(num, fd);
}

✔️ Description

  • Outputs the integer ’n’ to the given file descriptor.
  • 주어진 파일 설명자에 정수 'n'을 출력한다.

✔️ Return

⁉️ Notice

  • 파일 디스크립터에 대해 알아보자.

아래 코드부터는 구조체를 사용한 함수들이다.

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

🚀 ft_lstnew

t_list	*ft_lstnew(void *content)

  • 구현 코드

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

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

✔️ Description

  • Allocates (with malloc(3)) and returns a new lement. The variable ’content’ is initialized with the value of the parameter ’content’. The variable ’next’ is initialized to NULL.
  • 새 요소(이하 노드)에 content는 매개변수로 받은 content, next는 널로 초기화하여 반환한다.

✔️ Return

새 노드

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.

🚀 ft_lstadd_front

void	ft_lstadd_front(t_list **lst, t_list *new)

  • 구현 코드

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

✔️ Description

  • Adds the element ’new’ at the beginning of the list.
  • (연결리스트) 시작 부분에 new노드를 추가한다.

✔️ Return

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.

🚀 ft_lstsize

int		ft_lstsize(t_list *lst)

  • 구현 코드

    int		ft_lstsize(t_list *lst)
{
	size_t	len;

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

✔️ Description

  • Counts the number of elements in a list.
  • 리스트의 노드 수를 반환한다.

✔️ Return

노드의 개수

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.

🚀 ft_lstlast

t_list	*ft_lstlast(t_list *lst)

  • 구현 코드

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

✔️ Description

  • Returns the last element of the list.
  • 리스트의 마지막 노드를 반환한다.

✔️ Return

마지막 노드

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.

🚀 ft_lstadd_back

void	ft_lstadd_back(t_list **lst, t_list *new)

  • 구현 코드

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

	if (!lst || !new)
		return ;
	if (!(*lst))
		*lst = new;
	else
	{
		temp = ft_lstlast(*lst);
		temp->next = new;
	}
}

✔️ Description

  • Adds the element ’new’ at the end of the list.
  • 리스트 끝에 new노드를 추가합니다.

✔️ Return

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.

🚀 ft_lstdelone

void	ft_lstdelone(t_list *lst, void (*del)(void *))

  • 구현 코드

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

✔️ Description

  • Takes as a parameter an element and frees the memory of the element’s content using the function ’del’ given as a parameter and free the element. The memory of ’next’ must not be freed.
  • 노드를 매개변수로 취하는 del함수를 사용하여 노드의 콘텐츠 메모리를 해제하고, 노드를 free한다. next의 메모리를 free해서는 안된다.

✔️ Return

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.
  • 함수포인터에 대해 알아보자.
  • del함수가 콘텐츠를 free하므로 콘텐츠에 관한 free는 고려하지 않는다.

🚀 ft_lstclear

void	ft_lstclear(t_list **lst, void (*del)(void *))

  • 구현 코드

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

	now = *lst;
	while (now)
	{
		next = now->next;
		ft_lstdelone(now, del);
		now = next;
	}
	*lst = 0;
}

✔️ Description

  • Deletes and frees the given element and every successor of that element, using the function ’del’ and free(3).
    Finally, the pointer to the list must be set to NULL.
  • 리스트의 노드들을 전부 삭제(free)해야한다.
  • 노드 삭제 시 노드 내 컨텐츠 또한 삭제(free)되어야 한다.

✔️ Return

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.
  • 함수포인터에 대해 알아보자.
  • 이전 문제를 잘 활용한다.

🚀 ft_lstiter

void	ft_lstiter(t_list *lst, void (*f)(void *))

  • 구현 코드

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

✔️ Description

  • Iterates the list ’lst’ and applies the function ’f’ to the content of each element.
  • 연결리스트 lst의 각 노드의 콘텐츠를 f함수의 매개변수로 활용하여 f함수를 호출한다.

✔️ Return

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.
  • 함수포인터에 대해 알아보자.

🚀 ft_lstmap

t_list	*ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))

  • 구현 코드

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

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

✔️ Description

  • Iterates the list ’lst’ and applies the function ’f’ to the content of each element. Creates a new list resulting of the successive applications of the function ’f’. The ’del’ function is used to delete the content of an element if needed.
  • 리스트를 복제하여 새로운 리스트를 만든다.
  • 이때, 새로운 리스트의 content는 f함수의 반환값으로, 매개변수는 복제할 리스트의 content를 사용한다.

✔️ Return

⁉️ Notice

  • 구조체와 연결리스트에 대해 알아보자.
  • 함수포인터에 대해 알아보자.
profile
Hans Park
장안동 개발새발
다음 포스트

[42서울 / gnl] get_next_line 정리

0개의 댓글