[42Seoul] libft (part. 2)

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;
	int		i;

	if (!s)
		return (NULL);
	if (start >= ft_strlen(s))
		break;
	if (len >= ft_strlen(s))
		len = ft_strlen(s);
	if (!(ptr = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	i = 0;
	while (len--)
	{
		
		*(ptr + i) = *(char*)(s + start + i);
		i++;
	}
	*(ptr + i++) = '\0';
	return (ptr);
}

malloc(3)을 할당하고 문자열 's'에서 하위 문자열을 반환. 하위 문자열은 인덱스 'start'에서 시작되며 최대 크기는 'len'이다.

※ start >= ft_strlen(s) 의 경우에 동작을 하지 않아 중간에 if 문을 넣어서 작동하게끔 수정

 

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

char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*ptr;
	int	len;

	if (!s1 || !s2)
		return (0);
	len = ft_strlen(s1) + ft_strlen(s2);
	if (!(ptr = (char*)malloc(sizeof(char) * len + 1)))
		return (0);
	while (*s1)
		*ptr++ = *s1++;
	while (*s2)
		*ptr++ = *s2++;
	*ptr = '\0';
	return (ptr - len);
}

malloc(3)을 할당하고 새로운 문자열을 반환. 새로운 문자열은 문자열 's1'과 문자열 's2'의 연결된 형태.

 

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

char	*ft_strtrim(char const *s1, char const *set)
{
	char	*start;
	char	*end;
	char	*ptr;

	if (!s1)
		return (NULL);
	start = (char*)s1;
	end = (char*)s1 + ft_strlen(s1);
	while (*start)
	{
		if (!ft_strchr(set, *start))
			break ;
		start++;
	}
	while (start != NULL && start < end)
	{
		if (!ft_strchr(set, *end))
			break ;
		end--;
	}
	if (!(ptr = (char*)malloc(end - start + 2)))
		return (NULL);
	ft_strlcpy(ptr, start, end - start + 2);
	return (ptr);
}

malloc(3)을 할당하고 문자열의 처음과 끝에서 set에 지정된 문자가 제거된 문자열 s1의 사본을 반환.

주소의 이동과 사이즈 크기를 얼마만큼 설정해야 되는 지 그려보면서 제대로 파악을 하기

※1~2줄을 줄이려고 너무 하기보다는 일단 구현을 하고나서도 늦지 않았으니, 구동이 먼저 우선이 되어야 될 거 같다.

이 문제 때문에 허비된 시간만 5시간이 넘는 느낌... 테스터기 돌려서 안되는 부분이 가장 많았고 ㅠㅠㅠ

 

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

char		**free_malloc(char **ret)
{
	int	i;

	i = 0;
	while (ret[i])
	{
		free(ret[i]);
		i++;
	}
	free(ret);
	return (NULL);
}

static void	ft_strcpy(char *dst, char *src, char *to)
{
	while (src < to)
		*(dst++) = *(src++);
	*dst = 0;
}

int			ft_cnt(const char *s, char c)
{
	int	cnt;
	int	flag;

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

char		**ft_split(const char *s, char c)
{
	char	**ptr;
	char	*from;
	int		i;
	int		len;

	if (!s)
		return (NULL);
	len = ft_cnt(s, c);
	if (!(ptr = (char**)malloc(sizeof(char*) * (len + 1))))
		return (NULL);
	i = 0;
	while (i < len)
	{
		while (*s && *s == c)
			s++;
		from = (char*)s;
		while (*s && *s != c)
			s++;
		if (!(ptr[i] = (char*)malloc(sizeof(char) * (s - from + 2))))
			return (free_malloc(ptr));
		ft_strcpy(ptr[i++], from, (char*)s);
	}
	ptr[i] = NULL;
	return (ptr);
}

malloc(3)을 할당하고 구분 문자 'c'를 사용하여 문자열 's'을 분할하여 얻은 새로운 문자열 배열을 반환. 그 배열은NULL로 끝나야 합니다.

※static 여기 내에서만 쓸 수 있게끔 하는 함수. 그래서 계속 활용하는 걸 생활화 하는 게 중요하다.

while 도는 거를 제대로 파악이 중요하고, 어떤 구조인지, 그리고 그 전에 만들어 놓은 함수들이 어떻게 돌아가고 이름이 무엇인지에 대해 제대로 파악하는 게 중요하다.

 

char *ft_itoa(int n);

int			ft_abs(int nbr)
{
	return (nbr < 0 ? -nbr : nbr);
}

int			ft_len(int nbr)
{
	int		len;

	len = nbr <= 0 ? 1 : 0;
	while (nbr != 0)
	{
		nbr = nbr / 10;
		len++;
	}
	return (len);
}

char		*ft_itoa(int n)
{
	int		len;
	int		sign;
	char	*c;

	sign = n < 0 ? -1 : 1;
	len = ft_len(n);
	c = (char*)malloc(sizeof(char) * len + 1);
	if (!c)
		return (0);
	c[len--] = '\0';
	while (len >= 0)
	{
		c[len] = '0' + ft_abs(n % 10);
		n = ft_abs(n / 10);
		len--;
	}
	if (sign == -1)
		c[0] = '-';
	return (c);
}

malloc(3)을 할당하고 인수로 받은 정수를 나타내는 문자열을 반환. 음수 처리는 필수.

음수에 대한 조건 처리와 int 범위를 넘어서지 않게끔 함수를 제대로 짜야 한다.

 

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

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

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

'f'함수를 연속적으로 적용시킨 문자열. 할당 실패시 NULL.

문자열 's'의 각 문자에 'f'함수를 연속적으로 적용시킨 새로운 문자열을 만들기. 새로운 문자열은 malloc(3)을 할당.

 

ft_putnbr_fd

void	ft_putnbr_fd(int n, int fd)
{
	if (n == -2147483648)
		ft_putstr_fd("-2147483648", fd);
	else if (n < 0)
	{
		ft_putchar_fd('-', fd);
		ft_putnbr_fd(-n, fd);
	}
	else if (n < 10)
	{
		ft_putchar_fd(n + '0', fd);
		return ;
	}
	else
	{
		ft_putnbr_fd(n / 10, fd);
		ft_putchar_fd((n % 10) + '0', fd);
	}
	return ;
}

정수 'n'을 주어진 파일디스크립터로 출력.

int 범위에 대해서 정확히 해야하고, itoa 를 쓰려고 했으나, 테스터기에서 문제가 있다 평가가 되어서 재귀함수를 이용해서 구현