Part1
ubuntu์์ leak๋ฅผ ์ฒดํฌํ ๋ valgrind๋ก ํ์ธํ๋ฉด ๋๋ค.
size_t ?
์ด๋ก ์ ๊ฐ์ฅ ํฐ ์ฌ์ด์ฆ๋ฅผ ๋ด์ ์ ์๋ โunsignedโ ๋ฐ์ดํฐ ํ์
์ด๋ค. ์ด์์ฒด์ ์์ ๊ณ ์ ๋ ์ฌ์ด์ฆ๋ฅผ ๊ฐ์ง๋ค. ex) 32๋นํธ ์ด์์ฒด์ ์์๋ unsigned int, 64๋นํธ ์ด์์ฒด์ ์์๋ unsigned long long์ผ๋ก ๊ณ ์ ๋ ์ฌ์ด์ฆ๋ฅผ ๊ฐ์ง๋ค.
int ์ ๋ค๋ฅธ์ : int๋ ์ด์์ฒด์ ์ ๋ฐ๋ผ ํํํ ์ ์๋ ์ ์ํ์ด ๋ฐ๋์ ์๋ค๋ ์ ์ด๋ค.
const char ?
const ๋ ์์ํ ์ํจ๋ค๋ ๋ป์ ํค์๋๋ก ์ฒ์ ์ ํด์ง ๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค.
memset
memset์ 1๋ฐ์ดํธ ๋จ์๋ก ๊ฐ์ ์ด๊ธฐํ ํ๊ธฐ ๋๋ฌธ์ 0์ด ์๋ int ํ์
์ ์ซ์๋ฅผ ๋ฃ๊ฒ ๋๋ฉด ์์ํ ์ ์๋ ๊ฐ์ผ๋ก ์ธํ
๋๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก 0์ด ์๋ ๊ทธ๋ฆฌ๊ณ char ํ์
์ด ์๋ ๊ฐ์ ๋ฃ์ด์ ์ธํ
ํ๋ ค๊ณ ํ ๋๋ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฐ์ผ๋ก ์ธํ
ํ ์ ์๋ค. ์ฆ, 0์ด๋ char ํ์
๋ง ์ฌ์ฉํด์ผ ํ๋ค.
ex)
#include <iostream> #include <memory.h> using namespace std; int main() { int arr[10]; memset(arr, 1, sizeof(arr)); for (int i = 0; i < 10; i++) cout << arr[i]<<endl; }
1๋ฐ์ดํธ ๋จ์๋ก ์ด๊ธฐํ ํ๊ธฐ ๋๋ฌธ์ 00000001000000010000000100000001๋ก ๋ณํ ๋๋ค.
โ 16843009
ย
bzero
void bzero(void *s, size_t n);
memset ์ด๋ ์ ์ฌํ์ง๋ง ์ฃผ์ด์ง n๋งํผ 0์ผ๋ก ์ด๊ธฐํ ํ๋ค๋ ์ ์ด ๋ค๋ฅด๋ค.
ย
ย
restrict
ํ๋ก๊ทธ๋๋จธ๊ฐ ์ปดํ์ผ๋ฌ์๊ฒ restrict ๊ธฐ๋ฅ์ ์ํํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ ๊ทผ์ ๋ํ ์ต์ ํ๋ฅผ ํด๋ฌ๋ผ๊ณ ์๋ ค์ฃผ๋ ์ญํ ์ ๋ด๋นํ๋ค๊ณ ํ๋ค. ๋ํ ํน์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ๊ทผ ํ ์ ์๋ ํฌ์ธํฐ๊ฐ ๋จ ํ๋์์ ๋ณด์ฅํ๋ ํค์๋์ด๋ค.
memcpy && memmove
void *ft_memcpy(void *restrict dst, const void *restrict src, size_t n);
src๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ n ๊ธธ์ด๋งํผ dst๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ณต์ฌํด ๋ถ์ฌ๋ฃ๋ ํจ์์ด๋ค.
์ฌ์ฉ์ ์ฃผ์ํ ์ ์ char *ํ์
์ c์ธ์ด ๋ฌธ์์ด ํํ์ ๋ฌธ์์ด์ ์ ์ฒด๋ฅผ ๋ณต์ฌํ ๋๋ ๋งจ๋ค์ ๋ฌธ์์ด์ ๋์ ์๋ฆฌ๋ โ\0โ์ ๊ธธ์ด๋ ๊ณ์ฐํด ๋ฃ์ด์ผ ํ๊ธฐ๋๋ฌธ์ ๊ธธ์ด +1 ๋งํผ ํด์ฃผ์ด์ผ ํ๋ค. ๋ํ src ์dst์ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ด ๊ฒน์ณ์ ธ ์๋ ๊ณณ์์๋ ์ฌ์ฉํ์ง ๋ชปํ๋ค๊ณ ํ๋ค. ์ด๋ ๋ง์ฝ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฎ์ด์์์ผ ํ๋ค๋ฉด memmoveํจ์๋ฅผ ์ฌ์ฉํ๋ฉด๋๋ค.( but, ์์ฆ์ memcpy,memmove ๋๋ค ๋์ผํ๊ฒ ์๋ํ๋ค๊ณ ํ๋ค.)
memmove๋ memcpy์ ์ ์ฌํ์ง๋ง ๋ฒํผ๋ฅผ ์ฌ์ฉํ์ฌ ๋ณต์ฌํ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค. memcpy๋ณด๋ค ๋ ์์ ์ฑ์ด ๋๋ค.
strlcpy && strlcat
size_t ft_strlcpy(char *dst, const char *src, size_t dstsize); size_t ft_strlcat(char *dst, const char *src, size_t dstsize);
strlcpy ์ ๊ฒฝ์ฐ src์์ dstsize - 1(nul๊ฐ) ๋งํผ์ ๋ณต์ฌํ๋ ํจ์์ด๋ค.
strlcat ์ ๊ฒฝ์ฐ์๋ dst์ ๋ท๋ถ๋ถ๋ถํฐ src ์ dstsize๋งํผ์ ๋ฐ์ดํฐ๋ฅผ ์ฎ๊ฒจ ๋ถ์ด๋ ๊ฒ์ธ๋ฐ, ํน์ดํ๊ฒ ์๋ฆผ์ ๋ฐฉ์งํ๋ ๊ตฌ์กฐ์ฌ์ dstsize ๊ฐ dst์ ๊ธธ์ด+ nul๊ฐ๋ณด๋ค ์งง๋ค๋ฉด ( dstsize < dst_len + 1(nul๊ฐ)) dstsize + src_len์ ๋ฐํ๋ง ํ๊ณ , ์ด์ธ์ ๊ฒฝ์ฐ์๋ dst์ ๋ท๋ถ๋ถ์ ํด๋น ๊ฐ๋งํผ ์ฎ๊ฒจ ๋ถ์ด๋ฉฐ ๋ฐํ์ dst_len + src_len ์ ํ๋ค.
ย
ft_strchr && ft_strrchr
char *ft_strchr(const char *s, int c); char *ft_strrchr(const char *s, int c);
ft_strchr์ s ์์ c๊ฐ ์๋๋ถ๋ถ ๋ถํฐ์ ์ฃผ์๋ฅผ ๋ฆฌํดํด์ค๋ค. ๋ง์ผ ์กด์ฌํ์ง ์๋๋ค๋ฉด NULL์ ๋ฆฌํดํ๋ค.
ft_strrchr์ ft_strrchr๊ณผ ๋๊ฐ์ง๋ง ๋ค์์ ๋ถํฐ ์ผ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค. ๋๋ฌธ์์ด์ด ๋ค์ด์ฌ๋๋ฅผ ์ ์ํ์.
ย
memchr
void *ft_memchr(const void *b, int c, size_t n);
ํฌ์ธํฐ b์์ n๋ฐ์ดํธ ๋งํผ๊น์ง์์ c๊ฐ ์กด์ฌํ๋ ์ง๋ฅผ ํ์ธํ์ฌ void *๋ก ๋ฐํํด ์ค๋ค.
ย
memcmp
int ft_memcmp(const void *b1, const void *b2, size_t n)
์ผํ ์๊ฐํด๋ณด๋ฉด strcmp ์ ๋ฌด์จ์ฐจ์ด์ธ๊ฐ ํ๊ฒ ์ง๋ง strcmp๋ โ\0โ๋ค๋ก ๋ค๋ฅธ ๋ฌธ์์ด์ด์ด๋ ๋์ผํ๋ค ํ๋จํ์ง๋ง memcmp์ ์๋๋ค
strnstr
char *ft_strnstr(const char *haystack, const char *needle, size_t len);
haystack์์ len ๋ฐ์ดํธ ๋งํผ์ ๊ตฌ๊ฐ์์ needle์ด ํฌํจ๋์ด ์๋์ง ํ์ธํ๊ณ ์กด์ฌํ๋ฉด ๊ทธ๋์ ์ฃผ์๋ฅผ ๋ฆฌํดํ๋ค. needle์ด ๋น ๋ฌธ์์ด์ด๋ผ๋ฉด haystack์ ๊ทธ๋๋ก ๋ฐํํ๊ณ ๊ทธ์ธ์ ๊ฐ์ด ์กด์ฌํ์ง ์๋๋ค๋ฉด NULL์ ๋ฐํํ๋ค.
atoi
int ft_atoi(const char *str)
๋จผ์ ํ์ดํธ์คํ์ด์ค๋ฅผ ๋ฐ๊ณ ๋ถํธ๋ฅผ ํ์ธํ๋ค์ ( ๋ถํธ๋ ํ๋๋ง ํ์ธํ๋ค, ์ฌ๋ฌ๊ฐ ์์ผ๋ฉด 0๋ฆฌํด) ๊ทธ์ดํ ๋ณํ์ ํด์ค๋ค.
C์ธ์ด์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
์ฝ๋
์คํํ ํ๋ก๊ทธํ์ ์ฝ๋๊ฐ ์ ์ฅ๋๋ ์์ญ์ผ๋ก ํ
์คํธ ์์ญ์ด๋ผ๊ณ ๋ ๋ถ๋ฆฐ๋ค.
๋ฐ์ดํฐ
์ ์ญ ๋ณ์์ static(์ ์ ) ๋ณ์๊ฐ ํ ๋น๋๋ ์์ญ
ํ๋ก๊ทธ๋จ์ ์์๊ณผ ๋์์ ํ ๋น๋๊ณ , ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ๋์ด์ผ ๋ฉ๋ชจ๋ฆฌ์์ ์๋ฉธ๋จ
ํ
ํ์์ ์ํด ๋์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น ํ ๋ ์ฌ์ฉ
์ฆ ํ ๋นํด์ผ ํ ๋ฉ๋ชจ๋ฆฌ์ ํฌ๊ธฐ๋ฅผ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๋์ ๊ฒฐ์ ํด์ผ ํ๋ ๊ฒฝ์ฐ(๋ฐ ํ์๋) ์ ์ฉํ๊ฒ ์ฌ์ฉ๋๋ ๊ณต๊ฐ
์คํ
ํจ์ ํธ์ถ ์ ์์ฑ๋๋ ์ง์ญ ๋ณ์์ ๋งค๊ฐ ๋ณ์๊ฐ ์ ์ฅ๋๋ ์์ญ
ํจ์ ํธ์ถ์ด ์๋ฃ๋๋ฉด ์ฌ๋ผ์ง
calloc
void *calloc(size_t nmemb, size_t size);
malloc๊ณผ ์ ์ฌํ์ง๋ง ํจ์์ ๋งค๊ฐ๋ณ์๊ฐ 2๊ฐ์ด๋ค. nmemb์ ๊ฒฝ์ฐ ํ ๋นํ ๋ฉ๋ชจ๋ฆฌ์ ๋จ์ ๊ฐฏ์์ด๊ณ , size์ ๊ฒฝ์ฐ ํ๋๋น์ ํฌ๊ธฐ๋ฅผ ์ด์ผ๊ธฐํ๋ค. ๋ ๋ค๋ฅธ ์ฐจ์ด์ ์ malloc์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ด๊ธฐํ ํ์ง์์ ์ฐ๋ ๊ธฐ๊ฐ์ด ๋ค์ด์์ง๋ง calloc์ ๋ชจ๋ 0์ผ๋ก ์ด๊ธฐํ ์์ผ์ค๋ค.
strdup
char *ft_strdup(const char *str)
malloc์ ํด์ str์ ๋ณต์ฌํด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ๋ ํจ์๋ก malloc + strlcpy ๋ผ ์๊ฐํ๋ฉด ์ฝ๋ค.
ย
Part2
ย
malloc ํ free๋ฅผ ์ ์ ํ์ฌ์ผ ํ๋ค. ํจ์์์ ์ฌ์ฉํ ๋์ด์ ์ฌ์ฉํ์ง ์๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ฒฝ์ฐ์ ํํ์ฌ free๋ฅผ ํด ์ฃผ์ด์ผ ํ๋ค.
๋ฉ๋ชจ๋ฆฌ ๋์ ํ์ธ ๋ฐฉ๋ฒ
void leaks() { system("leaks ft_split"); } int main() { atexit(leaks); }
static ํจ์
static ๋ณ์๋ ํ๋ก๊ทธ๋จ์ด ์์๋ ๋ ํ ๋น๋๊ณ ํ๋ก๊ทธ๋จ์ด ๋๋ ๋ ํ๊ดด๋๋ค. ์ด๋ง์ธ์ฆ์จ ํจ์๊ฐ ๋๋๋ ๊ทธ ๊ฐ์ ๊ธฐ์ตํ๊ณ ์๋ค๋ ๊ฒ์ด๋ค.
๋ด๋ถ์ ์ ๋ณ์๋ ๋ค๋ฆํจ์์์๋ ์ฐธ์กฐํ ์ ์๋ค.
substr
char *ft_substr(char const *s, unsigned int start, size_t len);
s ์์์ start ๋ถํฐ์ substr์ ๋ฝ๋ ํจ์์ด๋ค. ์์ธ์ฒ๋ฆฌ๋ก๋ s๊ฐ null์ผ ๋ ๋ฐํ๋ํ null ๋ก ํ๊ณ , s์ ๊ธธ์ด๊ฐ start๋ณด๋ค ์๋ค๋ฉด ๋น๋ฌธ์์ด์ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ์ฌ ๋ฆฌํดํ๋ค. len ์ ์ต๋๊ธธ์ด๋ก ๋ง์ฝ s + start๋ถํฐ์ ๊ธธ์ด๊ฐ len ๋ณด๋ค ์๊ฒ๋๋ค๋ฉด len = s + start๊น์ง์ ๊ธธ์ด๋ก ํ๋ฉด ๋๋ค.
ย
strjoin
char *ft_strjoin(char const *s1, char const *s2);
๋ ๋ฌธ์์ด์ ๋ถ์ด๋ ํ์์ ํจ์์ด๋ค. ์ด๋ ์ฃผ์ํ ์ ์ ๋ ๋ฌธ์์ด ์ค NULL์ด ์กด์ฌํ ๋์ด๋ค. ๋๋ค NULL์ด๋ฉด NULL์ ๋ฐํํ๋ฉด ๋๊ณ ํ๋๋ง NULL์ด๋ฉด NULL์ด ์๋ ๋ฌธ์์ด์ strdupํจ์๋ก ๋ฆฌํดํด ์ฃผ๋ฉด ๋๋ค.๋๋ค NULL์ด ์๋๋ผ๋ฉด ๊ฐ๋จํ malloc์ผ๋ก ํ ๋น์ ํด์ฃผ๊ณ ์ด ์ฃผ์์ strlcpy, strlcat์ ํด์ฃผ๋ฉด ๋๋ค.
strtrim
char *ft_strtrim(char const *s1, char const *set);
s1์ ์์์ set์ ํฌํจ๋ ๊ฐ๋ค๋ก trim ํ์ฌ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ์ฌ ๋ฐํํ๋ ํจ์์ด๋ค. strchr ๊ณผ strrchr์ ์ด์ฉํ์ฌ set์ trimํ ์์์ ๊ณผ ๋์ ์ ๋ฐํ๋ฐ๋ ํจ์๋ฅผ ๊ตฌํํ๋ ํธ์ด ์ข๋ค.
์ฃผ์ํด์ผํ ์ ๋ค์ ์์์ด ๋๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ฒ ๋๋ค๋ฉด ๋น๋ฌธ์์ด์ ํ ๋นํด์ ๋ฐํํ์ฌ์ผ ํ๋ค.
split
leaks Report Version: 4.0 Process 10427: 162 nodes malloced for 12 KB Process 10427: 5 leaks for 112 total leaked bytes. 5 (112 bytes) ROOT LEAK: 0x7fbbf9c05820 [48] 1 (16 bytes) 0x7fbbf9c05850 [16] length: 1 "1" 1 (16 bytes) 0x7fbbf9c05860 [16] length: 2 "22" 1 (16 bytes) 0x7fbbf9c05870 [16] length: 3 "333" 1 (16 bytes) 0x7fbbf9c05880 [16] length: 4 "4444"
*str ์ด๋ ๊ฒ ๋จ๋๋ฐ ์ 16๋ฐ์ดํธ๋ ํ ๋น์ด ๋์๋์ง?
str์ ์ 12๋ฐ์ดํธ์ฉ ํ ๋น ๋์๋์ง?
strmapi
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
๋ฌธ์์ด s์ ๋ํด ๊ฐ ๋ฌธ์๋ง๋ค ํจ์ f๋ฅผ ์ ์ฉํ๋ f์ ์ฒซ๋ฒ์งธ ์ธ์๋ ์ธ๋ฑ์ค, ๋๋ฒ์งธ ์ธ์๋ ํด๋น ์ธ๋ฑ์ค ๋ฌธ์๋ฅผ ์ฌ์ฉํ๋ค. ์ด๋ ๊ฒ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํ์ฌ ๋ฐํํ๋ค.
striteri
void ft_striteri(char *s, void (*f)(unsigned int, char*));
strmapi์ ์ ์ฌํ์ง๋ง ๋ฆฌํด๊ฐ์ด ์๋ voidํจ์์ด๋ฉฐ ์ธ์๋ก๋ ์ธ๋ฑ์ค์ ๋ฌธ์์ ์ฃผ์๊ฐ์ ์ฌ์ฉํ๋ค.
putchar_fd && putstr_fd
void ft_putchar_fd(char c, int fd); void ft_putstr_fd(char *s, int fd);
ํ์ผ์๋ณ์๋ฅผ ํตํด ํด๋นํ์ผ์ ๋ฌธ์, ๋ฌธ์์ด์ writeํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฃ์ด์ค๋ค. ์ด๋ fd๋ ์์์ผ์ ์์ผ๋ฏ๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๋ฉด ๋๋ค.
ย
bonus part
lstnew
t_list *ft_lstnew(void *content);
malloc์ ํตํด ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น์ ํ๊ณ contents์ ๋ฑ๋กํ next๋
ธ๋๋ NULL๋ก ์ค์ ํด์ค๋ค.
lstadd_front
void ft_lstadd_front(t_list **lst, t_list *new);
๋งจ์์ ๋
ธ๋๋ก new๋ฅผ ๋ฃ์ด์ฃผ๊ธฐ์ํด newโnext๋ฅผ ๋งจ์ฒ์ ๊ฐ์ ์ฃผ์๋ก ํด์ฃผ๊ณ lst์ ์ฒซ์ฃผ์๋ฅผ new์ ์ฃผ์๋ก ๋ณ๊ฒฝํด์ฃผ๋ฉด ๋๋ค.
lstsize
int ft_lstsize(t_list *lst);
๊ฐ๋จํ ๋ค์ ๋
ธ๋๋ค์ ํ์ํ๋ฉฐ ๊ฐ์๋ฅผ ์๋ฉด ๋๋ค.
lstlatst
t_list *ft_lstlast(t_list *lst);
lstโnext๊ฐ NULL์ธ ๋
ธ๋๊ฐ ๋ง์ง๋ง ๋
ธ๋์ด๊ธฐ ๋๋ฌธ์ ์ด๋์ ์ฃผ์๋ฅผ ๋ฐํํ๋ฉด ๋๋ค.
lstadd_back
void ft_lstadd_back(t_list **lst, t_list *new);
lstadd_back์ด๋ ๋๊ฐ์ง๋ง ๋ค์ ๋ถ์ด๋ ๊ฒ์ด๋ผ ์๊ฐํ๋ฉด ๋๋ค.
lstdelone
void ft_lstdelone(t_list *lst, void (*del)(void *));
ํ ๋น๋ ๋ฆฌ์คํธ๋ฅผ ํด์ ํ๋ ํจ์์ด๋ค. ์ธ์๋ก ๋ฐ์ lst์ content๋ฅผ delํจ์๋ก ์ ๊ฑฐํ๊ณ lst์ ์ฒด๋ฅผ free ํ๋ฉด ๋๋ค.
lstclear
void ft_lstclear(t_list **lst, void (*del)(void *));
๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉด์ lstdelone์ ์ ์ฉ์์ผ์ฃผ๋ฉด ๋๋ค.
lstiter
void ft_lstiter(t_list *lst, void (*f)(void *));
๋จ์ํ ์ํํ๋ฉด์ ๊ฐ content์ ํจ์ f๋ฅผ ์ ์ฉ์ํค๋ฉด ๋๋ค.
lstmap
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *));
๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉด์ ๊ฐ content์ ํจ์ f๋ฅผ ์ ์ฉ์ํค๊ณ ์ ์ฉ์ํจ ๊ฒฐ๊ณผ๋ค์ content๋ก ๋ด์ ์๋ก์ด ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ๋ค. ์ฃผ์ํด์ผ ํ ์ ์ ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๋ฉด์ ํ ๋น์ ํ๊ฒ ๋ ๋ ๋๊ฐ๋๋ฅผ ์ ํด์ฃผ์ด์ผ ํ๋ค๋ ์ ์ด๋ค.
Loading Comments...