[42Seoul] libft (part. 1)

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

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

	ptr = b;
	i = 0;
	while (i++ < len)
		*ptr++ = (unsigned char)c;
	return (b);
}

 memory + setting : 메모리를 (특정 값으로) 세팅한다.

문자열 b에 (unsigned char) c 의 값으로 변환 된 len 바이트만큼 씁니다.

첫 번째 인수를 반환합니다.

 

void bzero(void *s, size_t n);

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

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

n 바이트만큼 문자열 s를 초기화 합니다. 

 

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

void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	size_t	i;
	char	*ptr;

	if (!dst && !src)
		return (0);
	i = 0;
	ptr = (char*)dst;
	while (i++ < n)
		*ptr++ = *((char*)src++);
	return (dst);
}

사이즈 n 바이트만큼 src 를 dst 에 복사한다. dst 와 src 가 겹치면 동작이 하지 않는다.

 

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

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

	if (!dst && !src)
		return (0);
	i = 0;
	ptr = (char*)dst;
	while (i < n)
	{
		*ptr = *(char*)src;
		if (*(char*)src == (char)c)
			return (ptr + 1);
		ptr++;
		src++;
		++i;
	}
	return (0);
}

 사이즈 n 바이트 만큼 문자열 src 를 문자열 dst 에 복사한다. 문자열 src 에서 문자 c 와 겹쳐지면 복사가 중지되고, 문자열 dst 에서 c 의 복사본이 반환된 후 포인터를 반환. 그렇지 않으면 n 바이트가 복사되고 NULL 포인터가 반환

 

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

void	*ft_memmove(void *dst, const void *src, size_t len)
{
	char		*cpy_dst;
	const char	*cpy_src;

	cpy_dst = dst;
	cpy_src = src;
	if (!dst && !src)
		return (0);
	if (cpy_dst > cpy_src)
	{
		cpy_dst += len;
		cpy_src += len;
		while (len--)
			*--cpy_dst = *--cpy_src;
	}
	else
		while (len--)
			*cpy_dst++ = *cpy_src++;
	return (dst);
}

 문자열 src에서 문자열 dst로 사이즈 len 만큼 복사한다.

두 문자열이 겹칠 수 있음. dst 의 원래 값을 반환

 하나의 문자열을 가지고 들어가게 되면 복사를 하지 못한 채 정보가 바뀌는 문제가 생길 수 있기 때문에 dst 가 src 보다 주소값이 크다면 뒤에서부터 복사를 하게 되면 문제가 생기지 않게 된다.

memmove 함수는 복사된 데이터가 저장될 위치와 복사할 데이터가 저장된 위치가 서로 겹쳐도 원하는 결과를 얻을 수 있습니다. 하지만 memcpy 함수의 경우에는 원하는 결과를 얻을 수 있을 수도 있고 얻지 못할 수도 있습니다. 대신, 속도는 memcpy 쪽이 더 빠릅니다

 

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

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

	ptr = (unsigned char*)s;
	i = 0;
	while (i++ < n)
		if (*ptr++ == (unsigned char)c)
			return ((void*)ptr - 1);
	return (0);
}

문자열 s에서 c (unsigned char)의 첫 번째 항목을 찾습니다.

찾은 바이트에 대한 포인터를 반환하거나 n 바이트 내에 해당 바이트가 없으면 NULL을 반환합니다.

 

 

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

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

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

바이트 문자열 s1을 바이트 문자열 s2와 비교하고 두 문자열 모두 길이가 n 바이트 인 것으로 간주됩니다.

두 문자열이 동일하면 0을 반환하고 그렇지 않으면 처음 두 바이트의 차이를 반환합니다.
(treated as unsigned char values, so that `\200' is greater than `\0', for example)

 

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

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

	if (!src)
		return (0);
	src_len = ft_strlen(src);
	if (!dstsize)
		return (src_len);
	i = 0;
	while (*src && i < dstsize - 1)
	{
		*dst++ = *src++;
		++i;
	}
	*dst = '\0';
	return (src_len);
}

size_t strlcat(char *dest, const char *src, size_t dstsize);

size_t	ft_strlcat(char *dest, const char *src, size_t dstsize)
{
	size_t	i;
	size_t	dest_len;
	size_t	src_len;

	i = 0;
	dest_len = ft_strlen(dest);
	src_len = ft_strlen(src);
	if (dstsize < dest_len + 1)
		return (dstsize + src_len);
	if (dstsize > dest_len + 1)
	{
		while (src[i] != '\0' && dest_len + 1 + i < dstsize)
		{
			dest[dest_len + i] = src[i];
			i++;
		}
	}
	dest[dest_len + i] = '\0';
	return (dest_len + src_len);
}

동일한 입력 매개 변수 및 출력 결과를 갖는 문자열을 복사하고 연결

대상 버퍼의 전체 크기를 취하고 공간이 있으면 NULL 종료를 보장합니다. NULL을위한 공간은 dstsize에 포함되어야합니다.

strlcpy()는 문자열 src에서 dst로 dstsize-1 까지 복사하여 dstsize가 0이 아니면 결과를 NULL로 종료

strlcat()은 dst 끝에 src 문자열을 추가합니다. 최대 dstsize-strlen (dst)-1자를 추가합니다. 그런 다음 dstsize가 0이거나 원래 dst 문자열이 dstsize보다 길지 않은 경우 NULL 종료

strlcpy () 및 strlcat () 함수는 생성하려는 문자열의 전체 길이를 반환합니다. strlcpy ()의 경우 이는 src의 길이를 의미합니다. strlcat ()의 경우 이는 dst의 초기 길이에 src의 길이를 더한 것을 의미

 

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

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

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

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

	ptr = (char*)s;
	while (*ptr++)
		;
	ptr--;
	while (*ptr != c)
	{
		if (ptr == s)
			return (NULL);
		ptr--;
	}
	return (ptr);
}

strchr () 함수는 s가 가리키는 문자열에서 c (문자로 변환 됨)의 첫 번째 발생을 찾습니다. 종료 널 문자는 문자열의 일부로 간주됩니다. 따라서 c가`\ 0 '이면 함수는 종료`\0'을 찾습니다.

strrchr () 함수는 c의 마지막 항목을 찾는 것을 제외하면 strchr ()과 동일합니다.

strchr () 및 strrchr () 함수는 찾은 문자에 대한 포인터를 반환하거나 문자가 문자열에 나타나지 않으면 NULL을 반환합니다.

 

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

char	*ft_strnstr(const char *haystack, const char *needle, size_t len)
{
	size_t	i;
	size_t	j;

	if (*needle == '\0')
		return ((char*)haystack);
	i = ft_strlen(haystack);
	j = ft_strlen(needle);
	if (i < j || len < j)
		return (NULL);
	while (len-- >= j && *haystack)
	{
		if (ft_memcmp(haystack, needle, j) == 0)
			return ((char*)haystack);
		haystack++;
	}
	return (NULL);
}

strnstr() 함수는 문자열 haystack에서 null로 끝나는 문자열 needle의 첫 번째 발생을 찾습니다. 여기서 len 문자 이하가 검색됩니다. '\ 0'문자 뒤에 나오는 문자는 검색되지 않습니다.

needle이 빈 문자열이면 haystack이 반환됩니다. needle이 haystack 어디에도 없으면 NULL이 반환됩니다. 그렇지 않으면 needle의 첫 번째 발생의 첫 번째 문자에 대한 포인터가 반환됩니다.

 

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

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

	ptr1 = (unsigned char *)s1;
	ptr2 = (unsigned char *)s2;
	i = 0;
	while (i++ < n)
	{
		if (*ptr1 != *ptr2 || *ptr1 == '\0' || *ptr2 == '\0')
			return (*ptr1 - *ptr2);
		ptr1++;
		ptr2++;
	}
	ptr1--;
	ptr2--;
	return (*ptr1 - *ptr2);
}

strncmp () 함수는 n 자 이하를 비교합니다. strncmp ()는 바이너리 데이터가 아닌 문자열을 비교하도록 설계 되었기 때문에`\ 0 '문자 뒤에 나오는 문자는 비교되지 않습니다.

strncmp () 함수는 문자열 s1이 문자열 s2보다 크거나 같거나 작으므로 0보다 크거나 같거나 작은 정수를 반환

 

int ft_atoi(const char *str)

int	ft_isspace(char c)
{
	if (9 <= c && c <= 13)
		return (1);
	if (c == 32)
		return (1);
	else
		return (0);
}

int	ft_atoi(const char *str)
{
	long long	sign;
	long long	nbr;

	sign = 1;
	nbr = 0;
	while (*str && ft_isspace(*str))
		str++;
	if (*str == '-')
		sign = -1;
	if (*str == '-' || *str == '+')
		str++;
	while (*str && '0' <= *str && *str <= '9')
	{
		nbr = (nbr * 10) + (*str - '0');
		if (nbr > 2147483647 && sign == 1)
			return (-1);
		if (nbr > 2147483648 && sign == -1)
			return (0);
		str++;
	}
	return ((int)(nbr * sign));
}

atoi () 함수는 가리키는 문자열의 초기 부분을 str에서 int 표현으로 변환합니다.

 

void *ft_calloc(size_t count, size_t size)

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

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

calloc () 함수는 각각 메모리의 Size 바이트 인 count 객체에 대해 충분한 공간을 연속적으로 할당하고 할당 된 메모리에 대한 포인터를 반환합니다. 할당 된 메모리는 값이 0 인 바이트로 채워집니다.

 

char *ft_strdup(const char *s1)

char	*ft_strdup(const char *s1)
{
	char	*ptr;
	int		len;
	int		i;

	len = ft_strlen(s1);
	if (!(ptr = (char*)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	i = 0;
	while (*s1)
		ptr[i++] = *(char*)s1++;
	ptr[i] = '\0';
	return (ptr);
}

strdup () 함수는 문자열 s1의 사본에 충분한 메모리를 할당하고 복사를 수행 한 후 포인터를 리턴