ft_printf - KimTaebin-ai/study_posts GitHub Wiki

int	main(void)
{
	int test_result;
	char *null_str;
	char *empty_str;
	int num;
	void *ptr;
	void *null_ptr = NULL;
	char *long_str;
	unsigned int u_num;

	null_str = NULL;
	empty_str = "";
	num = 42;
	u_num = UINT_MAX;
	ptr = #
	// 테스트 케이스 1: %c - 문자 출력
	test_result = ft_printf("1. %c\n", 'A');
	printf("Expected length: %d\n", test_result); // 예상 출력: "1. A\n" (길이 5)
	// 테스트 1-2: %c에 ASCII 코드 넣기
	ft_printf("1-2. %c\n", 65); // 예상 출력: "1-2. A\n"
	// 테스트 1-3: %c에 문자열을 넣었을 때 (비정상적인 입력)
	ft_printf("1-3. %c\n", "ㅎㅇ"); // 예상 동작: 비정상 동작 (컴파일러 경고 또는 오류)
	// 테스트 케이스 2: %s - 문자열 출력
	ft_printf("2. %s\n", "Hello, 42!"); // 예상 출력: "2. Hello, 42!\n"
	// 테스트 2-1: %s에 빈 문자열 전달
	ft_printf("2-1. %s\n", empty_str); // 예상 출력: "2-1. \n"
	// 테스트 2-2: %s에 NULL 포인터 전달
	ft_printf("2-2. %s\n", null_str); // 예상 출력: "2-2. (null)\n"
	// 테스트 케이스 3: %p - 포인터 출력
	ft_printf("3. %p\n", ptr); // 예상 출력: 포인터 주소값
	printf("3. %p\n", ptr);    // 비교용 표준 printf 출력

	// **테스트 케이스 3-1: %p에 NULL 포인터 전달**
	ft_printf("3-1. %p\n", null_ptr); // 예상 출력: "3-1. (nil)\n"
	printf("3-1. %p\n", null_ptr);    // 비교용 표준 printf 출력

	// 테스트 케이스 4: %d - 정수 출력
	ft_printf("4. %d\n", num); // 예상 출력: "4. 42\n"
	// 테스트 4-1: %d에 음수 전달
	ft_printf("4-1. %d\n", -123); // 예상 출력: "4-1. -123\n"
	// 테스트 4-2: %d에 INT_MAX 전달
	ft_printf("4-2. %d\n", INT_MAX); // 예상 출력: "4-2. 2147483647\n"
	// 테스트 4-3: %d에 INT_MIN 전달
	ft_printf("4-3. %d\n", INT_MIN); // 예상 출력: "4-3. -2147483648\n"
	// 테스트 4-4: %d에 str 전달
	ft_printf("4-4. %d\n", "test"); // 예상 출력:
	// 테스트 4-5: %d에 0 전달
	ft_printf("4-5. %d\n", 0); // 예상 출력: 0
	// 테스트 케이스 5: %i - 정수 출력 (정수형 동일)
	ft_printf("5. %i\n", num);   // 예상 출력: "5. 42\n"
									// 테스트 케이스 6: %u - 부호 없는 정수 출력
	ft_printf("6. %u\n", u_num); // 예상 출력: "6. 4294967295\n"
	// 테스트 케이스 7: %x - 16진수 (소문자) 출력
	ft_printf("7. %x\n", num); // 예상 출력: "7. 2a\n"
	// 테스트 7-1: %x에 0 전달
	ft_printf("7-1. %x\n", 0); // 예상 출력: "7-1. 0\n"
	// 테스트 7-2: %x에 UINT_MAX 전달
	ft_printf("7-2. %x\n", UINT_MAX); // 예상 출력: "7-2. ffffffff\n"
	// 테스트 케이스 8: %X - 16진수 (대문자) 출력
	ft_printf("8. %X\n", num); // 예상 출력: "8. 2A\n"
	// 테스트 8-2: %x에 UINT_MAX 전달
	ft_printf("8-2. %X\n", UINT_MAX); // 예상 출력: "8-2. FFFFFFFF\n"
	// 테스트 케이스 final: 다양한 형식 조합
	ft_printf("final. Char: %c, String: %s, Int: %d, Hex: %x\n", 'B',
		"42Gyeongsan", 123, 255);
	// 예상 출력: "final. Char: B, String: 42Gyeongsan, Int: 123, Hex: ff\n"
	// 테스트 케이스 추가: 넓은 포인터와 문자열 조합 테스트
	long_str = "This is a longer string to test";
	ft_printf("real final: Ptr: %p, Long Str: %s\n", long_str, long_str);
	// 예상 출력: 포인터와 문자열이 정상 출력

	return (0);
}

// cc -Wall -Wextra -Werror -o test ft_printf.c -L. libftprintf.a
// ./test

#include "ft_printf.h"
#include <stdio.h>

int	check_type(const char *bs, va_list ap)
{
	if (*bs == 'c')
		return (c_func(ap));
	else if (*bs == 's')
		return (s_func(ap));
	else if (*bs == 'p')
		return (p_func(ap));
	else if (*bs == 'd' || *bs == 'i')
		return (d_func(ap));
	else if (*bs == 'u')
		return (u_func(ap));
	else if (*bs == 'x')
		return (sx_func(ap));
	else if (*bs == 'X')
		return (lx_func(ap));
	else
		return (-1); // 오류  발생시 -1 리턴
}

int	count_bs(const char *bs, va_list ap)
{
	int	i;
	int	type_len;

	i = 0;
	while (*bs)
	{
		if (*bs == '%')
		{
			bs++; // %뒤 타입 확인 목적
			type_len = check_type(bs, ap);
			if (type_len == -1) // 널가드 필요
				return (-1);
			i += type_len;
		}
		else
		{
			if (write(1, bs, 1) == -1)
			{
				return (-1);
			}
			i++;
		}
		bs++;
	}
	return (i);
}

int	ft_printf(const char *bs, ...)
{
	va_list	argptr;
	int		bs_len;

	bs_len = 0;
	va_start(argptr, bs);
	bs_len = count_bs(bs, argptr);
	return (bs_len);
}

#include "ft_printf.h"

int	c_func(va_list ap)
{
	char	c;

	c = (char)va_arg(ap, int);
	if (write(1, &c, 1) == -1)
		return (-1);
	return (1);
}

int	s_func(va_list ap)
{
	char	*s;

	s = va_arg(ap, char *);
	if (s == NULL)
	{
		write(1, "(null)", 6);
		return (6);
	}
	if (write(1, s, ft_strlen(s)) == -1 || ft_strlen(s) > INT_MAX)
		return (-1);
	return (ft_strlen(s));
}

int	p_func(va_list ap)
{
	void				*ptr;
	unsigned long long	p;
	char				*pitoa;
	int					len;

	ptr = va_arg(ap, void *);
	if (ptr == NULL)
	{
		return (write(1, "(nil)", 5));
	}
	p = (unsigned long long)ptr;
	pitoa = ft_itoahex(p, "0123456789abcdef");
	len = ft_strlen(pitoa);
	write(1, "0x", 2);
	if (write(1, pitoa, len) == -1)
	{
		free(pitoa);
		return (-1);
	}
	free(pitoa);
	return (len + 2);
}

int	d_func(va_list ap)
{
	int		d;
	char	*ditoa;
	int		len;

	d = va_arg(ap, int);
	ditoa = ft_itoa(d);
	len = ft_strlen(ditoa);
	if (write(1, ditoa, len) == -1)
	{
		free(ditoa);
		return (-1);
	}
	free(ditoa);
	return (len);
}

int	u_func(va_list ap)
{
	unsigned int	u;
	char			*uitoa;
	int				len;

	u = va_arg(ap, unsigned int);
	uitoa = ft_itoa(u);
	len = ft_strlen(uitoa);
	if (write(1, uitoa, len) == -1)
	{
		free(uitoa);
		return (-1);
	}
	free(uitoa);
	return (len);
}

int	x_func(va_list ap, const char *hex)
{
	unsigned int	x;
	char			*xitoa;
	int				len;
	int				write_result;

	x = va_arg(ap, unsigned int);
	xitoa = ft_itoahex(x, hex);
	HANDLE_ERROR(!xitoa, return (-1));
	len = 0;
	while (xitoa[len])
		len++;
	write_result = write(1, xitoa, len);
	free(xitoa);
	HANDLE_ERROR(write_result == -1, return (-1));
	return (len);
}

int	sx_func(va_list ap)
{
	return (x_func(ap, HEX_CHARS_LOWER));
}

int	lx_func(va_list ap)
{
	return (x_func(ap, HEX_CHARS_UPPER));
}

#include "ft_printf.h"

int	sizen_h(unsigned long long n)
{
	int	i;

	i = 0;
	if (n == 0)
		i = 1;
	else
	{
		while (n)
		{
			n = n / 16;
			i++;
		}
	}
	return (i);
}

char	*ft_itoahex(unsigned long long n)
{
	int					size_n;
	char				*ia;
	char				*hex;
	unsigned long long	fn;

	size_n = sizen_h(n);
	ia = (char *)ft_calloc((size_n + 1), sizeof(char));
	if (ia == NULL)
		return (0);
	hex = "0123456789abcdef";
	fn = n;
	while (fn)
	{
		ia[size_n - 1] = *(hex + (fn % 16));
		fn = fn / 16;
		size_n--;
	}
	if (n == 0)
		ia[0] = '0';
	return (ia);
}
char	*ft_itoahex_large(unsigned long long n)
{
	int					size_n;
	char				*ia;
	char				*hex;
	unsigned long long	fn;

	size_n = sizen_h(n);
	ia = (char *)ft_calloc((size_n + 1), sizeof(char));
	if (ia == NULL)
		return (0);
	hex = "0123456789ABCDEF";
	fn = n;
	while (fn)
	{
		ia[size_n - 1] = *(hex + (fn % 16));
		fn = fn / 16;
		size_n--;
	}
	if (n == 0)
		ia[0] = '0';
	return (ia);
}

#ifndef FT_PRINTF_H
# define FT_PRINTF_H

# include "./libft/libft.h"
# include <limits.h>
# include <stdarg.h>
# include <stdlib.h>
# include <unistd.h>

# define HEX_CHARS_LOWER "0123456789abcdef"
# define HEX_CHARS_UPPER "0123456789ABCDEF"
# define HANDLE_ERROR(condition, action) \
	if (condition)                      \
	{                                   \
		action;                         \
	}

int		ft_printf(const char *bs, ...);

int		c_func(va_list ap);
int		s_func(va_list ap);
int		s_func(va_list ap);
int		p_func(va_list ap);
int		d_func(va_list ap);
int		u_func(va_list ap);
int		sx_func(va_list ap);
int		lx_func(va_list ap);

char	*ft_itoahex(unsigned long long n, const char *hex);

#endif