[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의 사본에 충분한 메모리를 할당하고 복사를 수행 한 후 포인터를 리턴