libft구현 함수(str, mem)
문자열 관련 함수들
- ft_strchr : char *ft_strchr(const char *s, int c) 검색을 원하는 문자열 s와 찾고싶은 문자 c를 인자로 받아서 s 안에 c가 존재하면 맨처음 c가 나온 주소를 리턴시켜주고 s 안에 c가 존재하지 않으면 Null포인터를 리턴해준다
char *ft_strchr(const char *s, int c)
{
int i;
char *parr;
i = 0;
parr = (char *)s;
while (parr[i])
{
if (parr[i] == (char)c)
return (parr + i);
i++;
}
if (parr[i] == (char)c)
return (parr + i);
return ((void *)0);
}- ft_strrchr : char *ft_strrchr(const char *s, int c) 검색을 원하는 문자열 s와 찾고싶은 문자 c를 인자로 받아서 s 안에 c가 존재하면 마지막에 c가 나온 주소를 리턴시켜주고 s 안에 c가 존재하지 않으면 Null포인터를 리턴해준다
char *ft_strrchr(const char *s, int c)
{
int i;
char *parr;
int equl;
i = 0;
equl = -1;
parr = (char *)s;
while (parr[i])
{
if (parr[i] == (char)c)
{
equl = i;
}
i++;
}
if (parr[i] == (char)c)
return (parr + i);
if (equl != -1)
return (parr + equl);
return ((void *)0);
}- ft_strdup : char *ft_strdup(const char *s1) 복사를 원하는 문자열 s1을 받아서 똑같은 크기만큼 malloc해서 공간을 할당한 후 내용을 복사하여서 새로 만들어진 문자열의 시작주소를 리턴시켜준다 단 malloc과정에서 오류가 발생하였을 시 NULL포인터 리턴해준다
#include "libft.h"
char *ft_strdup(const char *s1)
{
unsigned long len;
unsigned long i;
char *parr;
i = 0;
len = ft_strlen(s1);
parr = (char *)malloc(len + 1);
if (parr == 0)
return (0);
while (i < len)
{
parr[i] = s1[i];
i++;
}
parr[i] = 0;
return (parr);
}- ft_strlcat : size_t ft_strlcat(char *dest, char *src, size_t size) 복사를 하고싶은 문자열인 dest와 복사를 해올 문자열 src 복사를 하고싶은 바이트수인 size(dest의 길이 + 붙이고 싶은 길이 = size)를 인자로 받아서 size만큼 src의 내용을 dest의 끝에서부터 붙여넣어준다 리턴되는 값은 정상적인 경우 dest + src의 길이가 반환되고 dest의 길이보다 size가 같거나 작을 경우 src의 길이에 size를 더한 값이 반환된다.
#include "libft.h"
size_t ft_strlcat(char *dest, char *src, size_t size)
{
unsigned int i;
size_t j;
int len;
i = 0;
j = 0;
if (ft_strlen(dest) >= size)
return (ft_strlen(src) + size);
else
len = ft_strlen(dest) + ft_strlen(src);
while (dest[i])
{
size--;
i++;
}
while ((j + 1 < size && src[j]))
{
dest[i + j] = src[j];
j++;
}
dest[i + j] = 0;
return (len);
}- ft_strjoin : char *ft_strjoin(char const *s1, char const *s2) 문자열 s1에 문자열 s2를 합친 문자열을 할당하여 내용을 복사한 후 해당 문자열을 반환시켜준다 만약 malloc도중 문제가 발생했을 시 NULL포인터가 리턴된다.
#include "libft.h"
char *ft_strjoin(char const *s1, char const *s2)
{
int all_len;
char *parr;
all_len = 0;
all_len += ft_strlen(s1) + ft_strlen(s2);
parr = malloc(all_len + 1);
if (parr == 0)
return (0);
ft_memcpy(parr, (char *)s1, ft_strlen(s1));
ft_memcpy(parr + ft_strlen(s1), (char *)s2, ft_strlen(s2) + 1);
return (parr);
}- ft_strlcpy : size_t ft_strlcpy(char *dest, char *src, size_t size) 복사를 하고싶은 문자열인 dest와 복사를 해올 문자열 src 복사를 하고싶은 바이트수인 size(붙이고싶은 길이)를 인자로 받아서 dest의 처음부터 size만큼 src의 내용을 복사해준다 리턴되는 값은 src의 길이가 반환되어진다.
#include "libft.h"
size_t ft_strlcpy(char *dest, char *src, size_t size)
{
unsigned int i;
int src_size;
src_size = 0;
i = 0;
src_size = ft_strlen(src);
if (size == 0)
return (src_size);
while (i < size)
{
dest[i] = src[i];
if (i == size - 1)
dest[size - 1] = 0;
if (src[i] == 0)
break ;
i++;
}
return (src_size);
}
- ft_strlen : size_t ft_strlen(const char *s) 문자열 길이를 찾고싶은 문자열 s를 입력으로 받아 해당 문자열의 길이를 '\0'널문자 기준으로 계산한 후 문자열의 길이를 반환시켜준다
#include "libft.h"
size_t ft_strlen(const char *s)
{
int i;
i = 0;
while (s[i])
{
i++;
}
return (i);
}
- ft_strncmp : int ft_strncmp(char *s1, char *s2, size_t n) 문자열을 비교할 문자열 s1 s2 문자열을 비교하고싶은 길이인 n을 입력으로 받아서 n만큼 비교하였을때 문자열이 동일하면 0값을 반환해주고 문자열이 차이가 있으면 처음으로 차이가 발생한 부분의 아스키 코드값을 s1 - s2로 반환시켜준다.
#include "libft.h"
int ft_strncmp(char *s1, char *s2, size_t n)
{
if (n == 0)
return (0);
while (--n != 0)
{
if (*s1 == 0 || *s2 == 0)
break ;
if (*s1 != *s2)
return ((unsigned char)*s1 - (unsigned char)*s2);
s1++;
s2++;
}
return ((unsigned char)*s1 - (unsigned char)*s2);
}- ft_strnstr : char *ft_strnstr(const char *haystack, const char *needle, size_t len) 문자열 haystack의 len범위 안에 needle문자열이 존재하는지 검사하여 존재하면 해당문자열이 처음 발견된 주소를 반환시켜주고 찾지 못했을 경우 NULL포인터를 반환하여 준다.
#include "libft.h"
char *ft_strnstr(const char *haystack, const char *needle, size_t len)
{
size_t j;
size_t i;
char *str;
char *to_find;
str = (char *)haystack;
to_find = (char *)needle;
i = 0;
if (to_find[0] == 0)
return (str);
while (*str && i < len)
{
j = 0;
if (str[j] == to_find[j])
{
while (str[j] == to_find[j] && str[j] && to_find[j] && i + j < len)
j++;
if (to_find[j] == '\0')
return (str);
}
str++;
i++;
}
return ((void *)0);
}- ft_strtrim : char *ft_strtrim(char const *s1, char const *set) 문자열 s1에서 문자열 set에 포함되어진 문자들을 양끝에서 잘라준다 리턴되는값은 malloc과정에서 문제가 발생하면 NULL 포인터가 반환되어지고 정상 동작 하였을 시 잘라진 문자열이 반환되어진다
ex.) s1 = "012ABC3D456" set = "0123456" -> "ABC3D"
#include "libft.h"
static int str_set_test(char word, char *set)
{
int i;
i = 0;
while (set[i])
{
if (word == set[i])
return (0);
i++;
}
return (1);
}
static int trim_size(char *parr, char *set, int *min, int *max)
{
int i;
int count;
i = 0;
count = 1;
while (parr[i])
{
if (count == 1 && str_set_test(parr[i], (char *)set))
{
*min = i;
*max = i;
count = 2;
}
else if (count != 1 && str_set_test(parr[i], (char *)set))
*max = i;
i++;
}
return (count);
}
char *ft_strtrim(char const *s1, char const *set)
{
int min;
int max;
char *parr;
int i;
int count;
min = 0;
i = 0;
parr = (char *)s1;
count = trim_size(parr, (char *)set, &min, &max);
if (count == 1)
return (ft_strdup(""));
parr = malloc(sizeof(char) * (max + count - min));
if (parr == 0)
return ((void *)0);
parr[max + count - min - 1] = 0;
i = 0;
while (min <= max)
{
parr[i] = s1[min];
i++;
min++;
}
return (parr);
}mem관련 함수들
- ft_memchr : void *ft_memchr(const void *s, int c, size_t n) 검색을 원하는 주소인 s와 찾고싶은 문자 c 검색하고 싶은 길이 n을 인자로 받아서 s 안에 c가 존재하면 맨처음 c가 나온 주소를 리턴시켜주고 s 안에 c가 존재하지 않으면 Null포인터를 리턴해준다
#include "libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
unsigned long i;
char *parr;
parr = (char *)s;
i = 0;
if (n == 0)
return ((void *)0);
while (i < n)
{
if (parr[i] == (char)c)
return (&parr[i]);
i++;
}
return ((void *)0);
}- ft_memcmp : int ft_memcmp(const void *s1, const void *s2, size_t n) 데이터를 비교할 포인터 s1 s2 데이터를 비교하고싶은 길이인 n을 입력으로 받아서 n만큼 비교하였을때 값이 동일하면 0값을 반환해주고 값이 차이가 있으면 처음으로 차이가 발생한 부분의 아스키 코드값을 s1 - s2로 반환시켜준다.
#include "libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
size_t i;
unsigned char *arr;
unsigned char *arr2;
arr = (unsigned char *)s1;
arr2 = (unsigned char *)s2;
i = 0;
if (n == 0)
return (0);
while (i + 1 < n)
{
if (arr[i] != arr2[i])
return (arr[i] - arr2[i]);
i++;
}
return (arr[i] - arr2[i]);
}- ft_memcpy : void *ft_memcpy(void *dst, const void *src, size_t n) dst에 src의 내용을 n만큼 복사한다 리턴되는 값은 dst의 시작주소가 반환된다.
#include "libft.h"
void *ft_memcpy(void *dst, const void *src, size_t n)
{
size_t i;
i = 0;
if (dst == (void *)0 && src == (void *)0)
return (dst);
while (i < n)
{
((char *)dst)[i] = ((char *)src)[i];
i++;
}
return (dst);
}- ft_memmove : void *ft_memmove(void *dst, const void *src, size_t len) dst에 src의 내용을 n만큼 복사한다 리턴되는 값은 dst의 시작주소가 반환된다 ft_memcpy함수와 차이점은 dst 와 src의 범위가 겹쳐도 안전하게 복사가 진행되는 차이점이 있다.
#include "libft.h"
void *ft_memmove(void *dst, const void *src, size_t len)
{
unsigned long i;
i = 0;
if (dst < src)
{
while (i < len)
{
((char *)dst)[i] = ((char *)src)[i];
i++;
}
}
else if (dst > src)
{
while (i < len)
{
((char *)dst)[len - 1] = ((char *)src)[len - 1];
len--;
}
}
return (dst);
}- ft_memset : void *ft_memset(void *b, int c, size_t len) 초기화를 원하는 메모리의 주소값(b)을 받아서 len의 길이만큼 해당 주소의 값을 c로 바꾼다 리턴되는 값은 b의 시작주소값이 반환된다
#include "libft.h"
void *ft_memset(void *b, int c, size_t len)
{
unsigned char a;
size_t i;
a = (unsigned char)c;
i = 0;
while (i < len)
{
((unsigned char *)b)[i] = a;
i++;
}
return (b);
}is관련 함수들
- ft_isalnum : int ft_isalnum(int c) c를 받아서 해당 값이 ascii코드에서 숫자나 알파벳이 맞는지 확인하여 맞으면 1을 반환해주고 아니면 0을 반환해준다.
int ft_isalnum(int c)
{
if (c >= '0' && c <= '9')
return (1);
else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
return (1);
return (0);
}- ft_isalpha : int ft_isalpha(int c) c를 받아서 해당 값이 ascii코드에서 알파벳이 맞는지 확인하여 맞으면 1을 반환해주고 아니면 0을 반환해준다.
int ft_isalpha(int c)
{
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
return (1);
return (0);
}- ft_isdigit : int ft_isdigit(int c) c를 받아서 해당 값이 ascii코드 상으로 숫자가 맞는지 확인하여 맞으면 1을 반환해주고 아니면 0을 반환해준다.
int ft_isdigit(int c)
{
if (c >= '0' && c <= '9')
return (1);
return (0);
}- ft_isascii : int ft_isascii(int c) c를 받아서 해당 값이 ascii 범위인 0~127 범위가 맞으면 1을 반환해주고 아니면 0을 반환해준다,
int ft_isascii(int c)
{
if (c >= 0 && c <= 127)
return (1);
return (0);
}- ft_isprint : int ft_isprint(int c) c를 받아서 ascii코드에서 출력가능한 범위(32 ~ 126)가 맞으면 1을 반환해주고 아니면 0을 반환해준다.
int ft_isprint(int c)
{
if (c >= 32 && c <= 126)
return (1);
return (0);
}fd 함수들
- ft_putchar_fd : void ft_putchar_fd(char c, int fd) 입력받은 fd에 c문자를 출력시켜준다.
#include "libft.h"
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, 1);
}- ft_putstr_fd : void ft_putstr_fd(char *s, int fd) 입력받은 fd에 문자열 s를 출력시켜준다.
#include "libft.h"
void ft_putstr_fd(char *s, int fd)
{
int len;
len = ft_strlen(s);
write(fd, s, len);
}- ft_putendl_fd : void ft_putendl_fd(char *s, int fd) 입력받은 fd에 문자열 s를 출력시킨 후 개행해준다.
#include "libft.h"
void ft_putendl_fd(char *s, int fd)
{
int len;
len = ft_strlen(s);
write(fd, s, len);
write(fd, "\n", 1);
}- ft_putnbr_fd : void ft_putnbr_fd(int n, int fd) 입력받은 fd에 입력받은 int형 n을 숫자로 출력시켜준다.
#include "libft.h"
void ft_putnbr_fd(int n, int fd)
{
long long num;
num = n;
if (n < 0)
{
write(fd, "-", 1);
num = num * -1;
}
if (num < 10)
write(fd, &"0123456789"[num], 1);
else
{
ft_putnbr_fd(num / 10, fd);
ft_putnbr_fd(num % 10, fd);
}
}그외 함수들
- ft_atoi : int ft_atoi(const char *str) 문자열 str을 int형으로 변환시켜서 반환해준다.
int ft_atoi(const char *str)
{
int num;
int plus;
char *pstr;
plus = 1;
num = 0;
pstr = (char *)str;
while ((*pstr >= 9 && *pstr <= 13) || *pstr == 32)
pstr++;
if (*pstr == '+' || *pstr == '-')
{
if (*pstr == '-')
plus = plus * -1;
pstr++;
}
while (*pstr >= '0' && *pstr <= '9')
{
num = ((num * 10) + (*pstr - '0'));
pstr++;
}
if (plus == -1)
num = num * -1;
return (num);
}- ft_itoa : char *ft_itoa(int n) int형 n을 문자열로 변환시켜서 반환해준다 만약 malloc과정에서 오류가 발생했을 시 NULL포인터가 리턴된다.
#include "libft.h"
static int ft_itoalen(long long n)
{
int i;
i = 0;
if (n == 0)
return (1);
if (n < 0)
{
i++;
n = n * -1;
}
while (n != 0)
{
n = n / 10;
i++;
}
return (i);
}
char *ft_itoa(int n)
{
long long temp;
int count;
char *parr;
temp = n;
count = ft_itoalen(temp);
parr = (char *)malloc(count + 1);
if (parr == 0)
return (0);
if (temp < 0)
{
temp = temp * -1;
parr[0] = '-';
}
parr[count] = 0;
count--;
if (n == 0)
parr[0] = '0';
while (temp != 0)
{
parr[count] = temp % 10 + '0';
temp = temp / 10;
count--;
}
return (parr);
}- ft_bzero : void ft_bzero(void *s, size_t n) 문자열 s를 n범위만큼 0으로 초기화시켜준다
#include "libft.h"
void ft_bzero(void *s, size_t n)
{
unsigned char *arr;
size_t i;
arr = (unsigned char *)s;
i = 0;
while (i < n)
{
arr[i] = 0;
i++;
}
}- ft_calloc : void *ft_calloc(size_t count, size_t size) count로 원하는 크기를 size로 하나의 크기에 몇 바이트가 필요한지 입력을 받아 해당하는 공간만큼 malloc으로 할당해주고 값을 전부 0으로 초기화시켜준다 리턴값을 할당한 공간의 시작주소가 반환된다 만약 malloc과정에서 오류가 발생했을 시 NULL포인터가 리턴된다.
#include "libft.h"
void *ft_calloc(size_t count, size_t size)
{
char *parr;
size_t i;
i = 0;
parr = (char *)malloc(size * count);
if (parr == NULL)
return ((void *)0);
while (i < size * count)
{
parr[i] = 0;
i++;
}
return (parr);
}- ft_split : char **ft_split(char const *s, char c) 문자열 s를 구분자 c로 구분하여 각각 이차원배열에 담아서 반환시켜준다 만약 malloc과정에서 오류가 발생했을 시 NULL포인터가 리턴된다.
ex.) s = "abc1def1ghi" c = 1 -> {{'a','b','c'}{'d','e','f'}{'g','h','i'}}
#include "libft.h"
static void all_free(char **cut_str, int i)
{
int j;
j = 0;
while (j < i)
{
free(cut_str[j]);
j++;
}
free(cut_str);
}
static int word_cut(char c, char *str, int *word_size, int i)
{
int flag;
flag = 0;
while (str[i])
{
if (c == str[i] && flag == 1)
return (i);
flag = 1;
*word_size = *word_size + 1;
i++;
}
return (i);
}
static int add_word(char **cut_str, int word, char c, char *str)
{
int i;
int k;
int j;
int word_size;
int start;
i = -1;
j = 0;
while (++i < word)
{
k = -1;
word_size = 0;
while (str[j] == c)
j++;
start = j;
j = word_cut(c, str, &word_size, j);
cut_str[i] = (char *)malloc(sizeof(char) * (word_size + 1));
if (cut_str[i] == 0)
return (i);
while (++k < word_size)
cut_str[i][k] = str[start++];
cut_str[i][k] = '\0';
}
return (-1);
}
static int word_count(char c, char *str, int flag, int count)
{
int i;
i = 0;
while (str[i] != '\0')
{
if (str[i] == c)
flag = 1;
else
{
if (flag == 1)
count++;
flag = 0;
}
i++;
}
return (count);
}
char **ft_split(char const *s, char c)
{
int word;
char **cut_str;
int i;
i = 0;
word = word_count(c, (char *)s, 1, 0);
cut_str = (char **)malloc(sizeof(char *) * (word + 1));
if (cut_str == 0)
return (0);
cut_str[word] = 0;
if (word == 0)
return (cut_str);
i = add_word(cut_str, word, c, (char *)s);
if (i != -1)
{
all_free(cut_str, i);
return (0);
}
return (cut_str);
}- ft_substr : char *ft_substr(char const *s, unsigned int start, size_t len) 문자열 s에 start만큼 이동 후 len만큼을 잘라서 리턴해준다 만약 malloc과정에서 오류가 발생했을 시 NULL포인터가 리턴된다.
ex.) s = "abcdefghi" start = 3 len = 2 -> "de"
#include "libft.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
size_t i;
unsigned int arr_len;
char *parr;
i = 0;
arr_len = (int)ft_strlen(s);
if (arr_len < start || s[0] == 0)
{
parr = ft_strdup("");
return (parr);
}
if (arr_len < start + len)
{
len = arr_len - start;
}
parr = (char *)malloc(len + 1);
if (parr == 0)
return (0);
while (i < len && s[i + start])
{
parr[i] = s[i + start];
i++;
}
parr[i] = 0;
return (parr);
}- ft_tolower : int ft_tolower(int c) 입력으로 받은 c가 ascii코드상으로 대문자 알파벳이면 소문자로 변경후 반환해준다.
int ft_tolower(int c)
{
if (c >= 'A' && c <= 'Z')
c = c + 32;
return (c);
}- ft_toupper : int ft_toupper(int c) 입력으로 받은 c가 ascii코드상으로 소문자 알파벳이면 대문자로 변경후 반환해준다.
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
c = c - 32;
return (c);
}
프로그래머 희망자(휴직중)