본문 바로가기
프로젝트/42Seoul

42서울 라피신 4주차 (C09, C11, C12)

by soohykim 2025. 4. 9.
728x90
반응형

📒 C09

when

  • 23.01.30 월 09:30 ~ 24:00
  • 23.01.31 화 07:00 ~ 22:00

📁 정적 라이브러리

  • linking 단계에서 라이브러리 파일(*.lib)을 실행 바이너리에 포함
  • 라이브러리 동작 코드가 모두 실행 바이너리에 포함되어 별도의 추가 작업 없이 실행 바이너리 만으로 라이브러리 함수 사용
  • gcc
    • c : object 파일 생성
    • o : 생성 될 파일 이름 지정
  • ar : 컴파일된 오브젝트 파일을 묶어 주는 명령어 (압축)
    • r : 새로운 오브젝트 파일이면 추가 / 기존 파일이면 치환
    • c : 아카이브(라이브러리 파일) 생성 (경고 메세지 출력X)
    • u : 오브젝트 파일의 타임스탬프를 비교해 새로운 파일일 경우만 치환
    • s : 아카이브 인덱스 생성 (링크 속도가 빨라짐)
      -> ranlib : object에 대해 symbol index를 만들어 링크 속도 높임
    • d : 아카이브 모듈 삭제
    • t : 아카이브에 있는 파일 리스트 출력
    • v : 파일 크기, 갱신 시각 등 상세정보 출력 (verbose 모드)
    • x : 아카이브에서 오브젝트 파일 추출

📁 Makefile

  • linux 상 반복적으로 발생하는 컴파일을 쉽게하기 위해 사용하는 make 프로그램 설정 파일 (library 및 컴파일 환경 관리)
  • 프로그램 종속 구조를 빠르게 파악하고 관리가 용이하며 각 파일에 대한 반복적 명령의 자동화/재작성 최소화
  • make -p : make 내부에 정의된 매크로 리스트 나열
  • Makefile 구조
TARGET : DEPENDENCY
		command
        
// TARGET : 만들려는 파일 
// DEPENDENCY : 필요한 재료 (선택)
// command : shell 커맨드 명령을 줌 (tab으로 구분)

libft.a : ft_putchar.o ft_swap.o ft_putstr.o ft_strlen.o ft_strcmp.o
    gcc -o libft.a ft_putchar.o ft_swap.o ft_putstr.o ft_strlen.o ft_strcmp.o
  • Makefile 매크로 작성 (함수에서 상수 선언)
  • TARGET =<빌드 대상 이름> -> NAME
    SRCS =<source 파일 목록> -> 공백 구분
    OBJS =<object 파일 목록>
    INCLUDES=<헤더파일 매크로>
    CC =<컴파일 명령어 매크로> -> gcc, clang
    CFLAGS =<컴파일 옵션>
    AR =<아카이브 파일 압축 명령 매크로>
    ARFLAGS=<압축 옵션>
  • Makefile 명령어%.o : %.c
        $(CC) $(CFLAG) -c $< -o $@fclean : clean
         rm -f $(NAME)    : 생성된 오브젝트 파일 + 라이브러리 파일 삭제$(NAME) : &(OBJS)
         (AR) $(ARFLAG) $@ $^
  • .PHONY : all clean fclean re     : Makefile와 같은 폴더에 명령어와 같은 이름을 가진 파일이 존재하면 명령어를 실행하지 않음 (파일명 대신 타겟으로 인식)
  • re : fclean all    : fclean과 all 진행
  • clean :
         rm -f $(OBJS)    : 생성된 오브젝트 파일 삭제
  • all : $(NAME)   :매크로인 NAME 타겟을 찾고, %.o:%.c 규칙 찾아 명령어 수행

  • $@ : 타겟 이름
  • $* : 목표 이름에서 확장자가 없는 이름
  • $< : dependency 파일 목록의 첫 번째 파일에 대응
  • $? : 목표 파일보다 최근에 갱신된 파일 이름
  • $^ : dependency 파일 목록 전체에 대응
  • $? : 타겟보다 최신인 의존 파일에 대응
  • $% : 대상의 이름 (해당 규칙 대상이 아카이브인 경우)

1. ex00) libft

gcc -c -Wall -Wextra -Werror ft_putchar.c ft_swap.c ft_putstr.c ft_strlen.c ft_strcmp.c
ar rsc libft.a ft_putchar.o ft_swap.o ft_putstr.o ft_strlen.o ft_strcmp.o

2. ex01) Makefile

NAME=libft.a

SRCS=./srcs/ft_putchar.c ./srcs/ft_swap.c ./srcs/ft_putstr.c ./srcs/ft_strlen.c ./srcs/ft_strcmp.c
OBJS=$(SRCS:.c=.o)

INCLUDE=./includes/

%.o : %.c
	cc -Wall -Wextra -Werror -c $^ -I $(INCLUDE) -o $@

$(NAME) : $(OBJS)
	ar rc $@ $(OBJS)

all : $(NAME)

clean :
	rm -rf $(OBJS)

fclean : clean
	rm -rf $(NAME)

re : fclean all

.PHONY : clean fclean re

3. ex02) ft_split

#include <stdlib.h>

int	is_seperator(char c, char *charset)
{
	int		i;

	i = 0;
	while (charset[i])
	{
		if (c == charset[i])
			return (1);
		i++;
	}
	return (0);
}

int	ft_count_str(char *str, char *charset)
{
	int	i;
	int	count;

	i = 0;
	count = 0;
	while (str[i])
	{
		while (str[i] != 0 && is_seperator(str[i], charset))
			i++;
		if (str[i] != 0 && !is_seperator(str[i], charset))
			count++;
		while (str[i] != 0 && !is_seperator(str[i], charset))
			i++;
	}
	return (count);
}

char	*ft_split_str(char *str, char *charset)
{
	int		n;
	int		i;
	char	*split_str;

	n = 0;
	i = 0;
	while (str[n])
		n++;
	split_str = (char *)malloc(sizeof(char) * (n + 1));
	if (!split_str)
		return (0);
	while (str[i] != 0 && !is_seperator(str[i], charset))
	{
		split_str[i] = str[i];
		i++;
	}
	split_str[i] = 0;
	return (split_str);
}

char	**ft_split(char *str, char *charset)
{
	int		i;
	int		index;
	int		count;
	char	**s_str;

	i = 0;
	index = 0;
	count = ft_count_str(str, charset);
	s_str = (char **)malloc(sizeof(char *) * (count + 1));
	if (!s_str)
		return (NULL);
	while (str[i])
	{
		while (str[i] != 0 && is_seperator(str[i], charset))
			i++;
		if (str[i] != 0 && !is_seperator(str[i], charset))
		{
			s_str[index] = ft_split_str(&str[i], charset);
			index++;
		}
		while (str[i] != 0 && !is_seperator(str[i], charset))
			i++;
	}
	s_str[index] = 0;
	return (s_str);
}

📒 C11

when

  • 23.02.01 수 07:00 ~ 22:00

1. ex00) ft_foreach

  • 함수 포인터 이용
void	ft_foreach(int *tab, int length, void (*f)(int))
{
	int	i;

	i = 0;
	while (i < length)
	{
		f(tab[i]);
		i++;
	}
}

2. ex01) ft_map

#include <stdlib.h>

int	*ft_map(int *tab, int length, int (*f)(int))
{
	int	i;
	int	*map;

	i = 0;
	map = (int *)malloc(sizeof(int) * (length + 1));
	if (!map)
		return (0);
	while (i < length)
	{
		map[i] = f(tab[i]);
		i++;
	}
	return (map);
}

3. ex02) ft_any

int	ft_any(char **tab, int (*f)(char*))
{
	int	i;

	i = 0;
	while (tab[i])
	{
		if (f(tab[i]) != 0)
			return (1);
		i++;
	}
	return (0);
}

4. ex03) ft_count_if

int	ft_count_if(char **tab, int length, int (*f)(char*))
{
	int	i;
	int	count;

	i = 0;
	count = 0;
	while (i < length)
	{
		if (f(tab[i]) != 0)
				count++;
		i++;
	}
	return (count);
}

5. ex04) ft_is_sort

  • 정렬이 되어 있으면 1, 아니면 0
int	ft_is_sort(int *tab, int length, int (*f)(int, int))
{
	int	i;
	int	f1;
	int	f2;

	i = 0;
	f1 = 0;
	f2 = 0;
	if (length <= 2)
		return (1);
	while (i + 1 < length)
	{
		if (f(tab[i], tab[i + 1]) > 0)
			f1 = 1;
		if (f(tab[i], tab[i + 1]) < 0)
			f2 = 1;
		i++;
	}
	if ((f1 + f2) == 2)
		return (0);
	return (1);
}

6. ex05) do-op

  • MAKEFILE
NAME=do-op

SRCS=ft_calculator.c ft_putnbr.c main.c
OBJS=$(SRCS:.c=.o)

%.o : %.c
	cc -Wall -Wextra -Werror -c $^ -o $@

$(NAME) : $(OBJS)
	cc -Wall -Wextra -Werror -o $(NAME) $(OBJS)

all : $(NAME)

clean :
	rm -rf $(OBJS)

fclean : clean
	rm -rf $(NAME)

re : fclean all

.PHONY : clean fclean re
  • main.c
#include <unistd.h>

int		add(int op1, int op2);
int		sub(int op1, int op2);
int		mul(int op1, int op2);
int		div(int op1, int op2);
int		rem(int op1, int op2);
void	ft_putnbr(int nb);

int	ft_strlen(char *str)
{
	int	i;

	i = 0;
	while (str[i])
		i++;
	return (i);
}

int	ft_atoi(char *str)
{
	long long	value;
	int			sign;

	value = 0;
	sign = 1;
	while (*str == ' ' || *str == '\r' || *str == '\f'
		|| *str == '\t' || *str == '\v' || *str == '\n')
		str++;
	while (*str == '-' || *str == '+')
	{
		if (*str == '-')
			sign *= -1;
		str++;
	}
	while (*str >= '0' && *str <= '9')
	{
		value = (value * 10) + (*str - '0');
		str++;
	}
	return ((int)(value * sign));
}

int	is_operator(char *cal, int op2)
{
	int	len;

	len = ft_strlen(cal);
	if (len != 1)
		return (-1);
	if (*cal == '+')
		return (0);
	if (*cal == '-')
		return (1);
	if (*cal == '*')
		return (2);
	if (*cal == '/' && op2 != 0)
		return (3);
	else if (*cal == '/' && op2 == 0)
		return (-2);
	if (*cal == '%' && op2 != 0)
		return (4);
	else if (*cal == '%' && op2 == 0)
		return (-3);
	return (-1);
}

void	is_error(int error)
{
	if (error == -1)
		write(1, "0\n", 2);
	else if (error == -2)
		write(1, "Stop : division by zero\n", 24);
	else if (error == -3)
		write(1, "Stop : modulo by zero\n", 22);
}

int	main(int argc, char *argv[])
{
	int	op1;
	int	op2;
	int	cal;
	int	answer;
	int	(*fp[5])(int,	int);

	if (argc != 4)
		return (0);
	op1 = ft_atoi(argv[1]);
	op2 = ft_atoi(argv[3]);
	cal = is_operator(argv[2], op2);
	if (cal < 0 || cal > 4)
	{
		is_error(cal);
		return (0);
	}
	fp[0] = add;
	fp[1] = sub;
	fp[2] = mul;
	fp[3] = div;
	fp[4] = rem;
	answer = fp[cal](op1, op2);
	ft_putnbr(answer);
	write(1, "\n", 1);
	return (0);
}
  • ft_calculator.c
#include <unistd.h>

int	add(int op1, int op2)
{
	return (op1 + op2);
}

int	sub(int op1, int op2)
{
	return (op1 - op2);
}

int	mul(int op1, int op2)
{
	return (op1 * op2);
}

int	div(int op1, int op2)
{
	return (op1 / op2);
}

int	rem(int op1, int op2)
{
	return (op1 % op2);
}
  • ft_putnbr.c
#include <unistd.h>

void	ft_putchar(char c)
{
	write(1, &c, 1);
}

void	ft_putnbr(int nb)
{
	if (nb == -2147483648)
	{
		write(1, "-2147483648", 11);
	}
	else
	{
		if (nb < 0)
		{
			nb *= -1;
			write(1, "-", 1);
		}
		if (nb >= 10)
		{
			ft_putnbr(nb / 10);
			ft_putnbr(nb % 10);
		}
		else
		{
			ft_putchar(nb + '0');
		}
	}
}

7. ex06) ft_sort_string_tab

  • 정렬
int	ft_count_tab(char **tab)
{
	int	i;

	i = 0;
	while (tab[i])
		i++;
	return (i);
}

int	ft_strcmp(char *s1, char *s2)
{
	int	i;

	i = 0;
	while (s1[i] != 0 && s2[i] != 0)
	{
		if (s1[i] != s2[i])
			return (s1[i] - s2[i]);
		i++;
	}
	return (0);
}

void	ft_swap(char **s1, char **s2)
{
	char *temp;

	temp = *s1;
	*s1 = *s2;
	*s2 = temp;
}

void	ft_sort_string_tab(char **tab)
{
	int		i;
	int		j;
	int		size;

	i = 0;
	size = ft_count_tab(tab);
	while (i < size - 1)
	{
		j = 0;
		while (j < size - i - 1)
		{
			if (ft_strcmp(tab[j], tab[j + 1]) > 0)
			{
				ft_swap(&tab[j], &tab[j + 1]);
			}
			j++;
		}
		i++;
	}

8. ex07) ft_advancde_sort_string_tab

  • 함수 포인터 이용 정렬
int	ft_count_tab(char **tab)
{
	int	i;

	i = 0;
	while (tab[i])
		i++;
	return (i);
}

void	ft_swap(char **s1, char **s2)
{
	char *temp;

	temp = *s1;
	*s1 = *s2;
	*s2 = temp;
}

void	ft_advanced_sort_string_tab(char **tab, int (*cmp)(char *, char *))
{
	int		i;
	int		j;
	int		size;

	i = 0;
	size = ft_count_tab(tab);
	while (i < size - 1)
	{
		j = 0;
		while (j < size - i - 1)
		{
			if ((*cmp)(tab[j], tab[j + 1]) > 0)
			{
				ft_swap(&tab[j], &tab[j + 1]);
			}
			j++;
		}
		i++;
	}
}

C11 main.c

1. ex00) ft_foreach

#include <stdio.h>

extern void	ft_foreach(int* tab, int length, void(*f)(int));

void test_print(int a) {
	printf("%d\n", a);
}

int main() {
	int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

	ft_foreach(arr, 10, &test_print);

	return 0;
}

2. ex01) ft_map

#include <stdio.h>

extern int* ft_map(int *tab, int length, int (*f)(int));

int func(int a) {
	return (2 * a);
}

int main() {
	int tab[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

	for (int i = 0; i < 10; i++) {
		printf("%d ", tab[i]);
	}
	printf("\n답 : 0 1 2 3 4 5 6 7 8 9\n");

	int* arr = ft_map(tab, 10, &func);

	for (int i = 0; i < 10; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n답 : 0 2 4 6 8 10 12 14 16 18\n");

	return 0;
}

3. ex02) ft_any

#include <stdio.h>
#include <string.h>

extern int ft_any(char** tab, int (*f)(char*));

int	func(char* str) {
	return strcmp(str, "abc") == 0;
}

int main() {
	char* tab[4] = {"hello", "world", "bye", 0};
	printf("%d\n", ft_any(tab, &func));

	char* tab2[4] = {"hello", "world", "abc", 0};
	printf("%d\n", ft_any(tab2, &func));

	char* tab3[4] = {"hello", "abc", "abc", 0};
	printf("%d\n", ft_any(tab3, &func));

	return 0;
}

4. ex03) ft_count_if

#include <stdio.h>
#include <string.h>

extern int ft_count_if(char** tab, int length, int (*f)(char*));

int	func(char* str) {
	return strcmp(str, "abc") == 0;
}

int main() {
	char* tab[3] = {"hello", "world", "bye"};
	printf("%d\n", ft_count_if(tab, 3, &func));

	char* tab2[3] = {"hello", "world", "abc"};
	printf("%d\n", ft_count_if(tab2, 3, &func));

	char* tab3[3] = {"hello", "abc", "abc"};
	printf("%d\n", ft_count_if(tab3, 3, &func));

	return 0;
}

5. ex04) ft_is_sort

#include <stdio.h>

extern int ft_is_sort(int* tab, int length, int (*f)(int, int));

int test_compare(int a, int b) {
	return a - b;
}

void test_is_sort(int* tab, int length) {
	for (int i = 0; i < length; i++) {
		printf("%d ", tab[i]);
	}
	printf("=> %d\n", ft_is_sort(tab, length, &test_compare));
}

int main() {
	int arr1[] = {1, 2, 3, 4, 5, 6};
	test_is_sort(arr1, 6);

	int arr2[] = {6, 5, 4, 3, 2, 1};
	test_is_sort(arr2, 6);

	int arr3[] = {2, 3, 1, 4, 5, 6};
	test_is_sort(arr3, 6);

	int arr4[] = {6, 4, 2, 1, 3, 5};
	test_is_sort(arr4, 6);

	int arr5[] = {1, 2, 2, 3, 4, 5};
	test_is_sort(arr5, 6);

	return 0;
}

7. ex06) ft_sort_string_tab

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

extern void ft_sort_string_tab(char **tab);

int	ft_strlen(char *src)
{
	int	i;

	i = 0;
	while (*(src + i))
		i++;
	return (i);
}

char	*ft_strdup(char *src)
{
	char	*dest;
	int		n;
	int		i;

	i = 0;
	n = ft_strlen(src);
	dest = (char *)malloc(sizeof(char) * (n + 1));
	if (!dest)
		return (NULL);
	while (*(src + i))
	{
		*(dest + i) = *(src + i);
		i++;
	}
	*(dest + i) = '\0';
	return (dest);
}

void test(char **tab) {
	printf("---table start---\n");
	for (int i = 0; tab[i] != NULL; i++) {
		printf("%s\n", tab[i]);
	}
	printf("---sort---\n");
	ft_sort_string_tab(tab);
	for (int i = 0; tab[i] != NULL; i++) {
		printf("%s\n", tab[i]);
	}
	printf("---end---\n");
}

int main(int argc, char* argv[]) {
	char** arr = (char**)malloc(sizeof(char*) * argc);

	for (int i = 0; i < argc - 1; i++) {
		arr[i] = ft_strdup(argv[i + 1]);
	}
	arr[argc - 1] = NULL;

	test(arr);

	for (int i = 0; i < argc - 1; i++) {
		free(arr[i]);
	}
	free(arr);

	return 0;
}

8. ex07) ft_advancde_sort_string_tab

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

extern void ft_advanced_sort_string_tab(char **tab, int (*cmp)(char *, char *));

int	ft_strcmp(char *s1, char *s2)
{
	int	i;

	i = 0;
	while (s1[i] != 0 || s2[i] != 0)
	{
		if (s1[i] != s2[i])
		{
			return (s1[i] - s2[i]);
		}
		i++;
	}
	return (0);
}

void test(char **tab) {
	printf("---table start---\n");
	for (int i = 0; tab[i] != NULL; i++) {
		printf("%s\n", tab[i]);
	}
	printf("---sort---\n");
	ft_advanced_sort_string_tab(tab, &ft_strcmp);
	for (int i = 0; tab[i] != NULL; i++) {
		printf("%s\n", tab[i]);
	}
	printf("---end---\n");
}

int main(int argc, char* argv[]) {
	char** arr = (char**)malloc(sizeof(char*) * argc);

	for (int i = 0; i < argc - 1; i++) {
		arr[i] = strdup(argv[i + 1]);
	}
	arr[argc - 1] = NULL;

	test(arr);

	for (int i = 0; i < argc - 1; i++) {
		free(arr[i]);
	}
	free(arr);

	return 0;
}

📁 C언어 빌드과정

1) 전처리 (preprocessing) -> 확장된 소스 코드 (.h, .c)
2) 컴파일 (compilation) -> 어셈블리 코드 (.s)
3) 어셈블 (assembling) -> 오브젝트 코드 (.o)
4) 링크 (linking) -> 머신 코드 실행파일 (.exe, .out)

📒 C12

when

  • 23.02.02 목 07:00 ~ 23:00

1. ex00) ft_create_elem

2. ex01) ft_list_push_front

3. ex02) ft_list_size

4. ex03) ft_list_last

5. ex04) ft_list_push_back

6. ex05) ft_list_push_strs

7. ex06) ft_list_clear

8. ex07) ft_list_at

9. ex08) ft_list_reverse

10. ex09) ft_list_foreach

11. ex10) ft_list_foreach_if

12. ex11) ft_list_find

13. ex12) ft_list_remove_if

14. ex13) ft_list_merge

15. ex14) ft_list_sort

16. ex15) ft_list_reverse_fun

17. ex16) ft_sorted_list_insert

18. ex17) ft_sorted_list_merge

C12 main.c

1. ex00) ft_create_elem

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

t_list	*ft_create_elem(void *data);

int	main(void)
{
	t_list	*list;
	char	*c;

	c = "TEST";
	list = ft_create_elem(c);
	printf("%s, %p\n", list->data, list->next);
	return (0);
}

2. ex01) ft_list_push_front

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

void	ft_list_push_front(t_list **begin_list, void *data);

int	main(void)
{
	t_list	*list;

	list = NULL;
	ft_list_push_front(&list, "THIRD");
	ft_list_push_front(&list, "SECOND");
	ft_list_push_front(&list, "FIRST");
	while (list)
	{
		printf("%s, %p\n", list->data, list->next);
		list = list->next;
	}
	return (0);
}

3. ex02) ft_list_size

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

int	ft_list_size(t_list *begin_list);

int	main(void)
{
	t_list	*list;

	list = ft_create_elem("FIRST");
	list->next = ft_create_elem("SECOND");
	printf("%d\n", ft_list_size(list));
	return (0);
}

4. ex03) ft_list_last

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

t_list	*ft_list_last(t_list *begin_list);

int	main(void)
{
	t_list	*list;

	list = ft_create_elem("FIRST");
	list->next = ft_create_elem("SECOND");
	list->next->next = ft_create_elem("THIRD");
	printf("%s, %p\n", ft_list_last(list)->data, ft_list_last(list)->next);
	return (0);
}

5. ex04) ft_list_push_back

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

void	ft_list_push_back(t_list **begin_list, void *data);

int	main(void)
{
	t_list	*list;

	list = NULL;
	ft_list_push_back(&list, "FIRST");
	ft_list_push_back(&list, "SECOND");
	printf("%s, %p\n", list->data, list->next);
	printf("%s, %p\n", list->next->data, list->next->next);
	return (0);
}

6. ex05) ft_list_push_strs

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

t_list	*ft_list_push_strs(int size, char **strs);

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"THIRD", "SECOND", "FIRST"};

	list = ft_list_push_strs(0, strs);
	list = ft_list_push_strs(3, strs);
	while (list)
	{
		printf("%s, %p\n", list->data, list->next);
		list = list->next;
	}
	return (0);
}

7. ex06) ft_list_clear

#include <stdio.h>
#include <stdlib.h>
#include "ft_list.h"

void	ft_list_clear(t_list *begin_list, void (*free_fct)(void *));
t_list	*ft_list_push_strs(int size, char **strs);

void	free_fct(void *data)
{
	free(data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"THIRD", "SECOND", "FIRST"};

	list = ft_list_push_strs(3, strs);
	printf(">>>BEFORE<<<\n");
	while (list)
	{
		printf("%s, %p\n", list->data, list->next);
		list = list->next;
	}
	ft_list_clear(list, &free_fct);
	printf(">>>AFTER<<<\n");
	while (list)
	{
		printf("%s, %p\n", list->data, list->next);
		list = list->next;
	}
	return (0);
}

8. ex07) ft_list_at

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

t_list	*ft_list_at(t_list *begin_list, unsigned int nbr);
t_list	*ft_list_push_strs(int size, char **strs);

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"THIRD", "SECOND", "FIRST"};

	list = ft_list_push_strs(3, strs);
	list = ft_list_at(list, 2);
	if (list)
		printf("%s, %p\n", list->data, list->next);
	else
		printf("NULL\n");
	return (0);
}

9. ex08) ft_list_reverse

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

void	ft_list_reverse(t_list **begin_list);
t_list	*ft_list_push_strs(int size, char **strs);

int	main(void)
{
	t_list	*list;
	t_list	*temp;
	char	*strs[3] = {"FIRST", "SECOND", "THIRD"};

	list = ft_list_push_strs(3, strs);
	temp = list;
	printf(">>>BEFORE<<<\n");
	while (temp)
	{
		printf("%s, %p\n", temp->data, temp->next);
		temp = temp->next;
	}
	ft_list_reverse(&list);
	temp = list;
	printf(">>>AFTER<<<\n");
	while (temp)
	{
		printf("%s, %p\n", temp->data, temp->next);
		temp = temp->next;
	}
	return (0);
}

10. ex09) ft_list_foreach

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

void	ft_list_foreach(t_list *begin_list, void (*f)(void *));
t_list	*ft_list_push_strs(int size, char **strs);

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"THIRD", "SECOND", "FIRST"};

	list = ft_list_push_strs(3, strs);
	ft_list_foreach(list, &print_data);
	return (0);
}

11. ex10) ft_list_foreach_if

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

void	ft_list_foreach_if(t_list *begin_list,
			void (*f)(void *), void *data_ref, int (*cmp)());
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

int	ft_strcmp(char *s1, char *s2)
{
	unsigned char	*s3;
	unsigned char	*s4;

	s3 = (unsigned char *)s1;
	s4 = (unsigned char *)s2;
	while (*s3 || *s4)
	{
		if (*s3 - *s4)
			return (*s3 - *s4);
		s3++;
		s4++;
	}
	return (0);
}

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"THIRD", "SECOND", "FIRST"};

	list = ft_list_push_strs(3, strs);
	ft_list_foreach(list, &print_data);
	ft_list_foreach_if(list, &print_data, "SECOND", &ft_strcmp);
	return (0);
}

12. ex11) ft_list_find

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

t_list	*ft_list_find(t_list *begin_list, void *data_ref, int (*cmp)());
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

int	ft_strcmp(char *s1, char *s2)
{
	unsigned char	*s3;
	unsigned char	*s4;

	s3 = (unsigned char *)s1;
	s4 = (unsigned char *)s2;
	while (*s3 || *s4)
	{
		if (*s3 - *s4)
			return (*s3 - *s4);
		s3++;
		s4++;
	}
	return (0);
}

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"THIRD", "SECOND", "FIRST"};

	list = ft_list_push_strs(3, strs);
	printf(">>>BEFORE<<<\n");
	ft_list_foreach(list, &print_data);
	list = ft_list_find(list, "SECOND", &ft_strcmp);
	printf(">>>AFTER<<<\n");
	ft_list_foreach(list, &print_data);
	return (0);
}

13. ex12) ft_list_remove_if

#include <stdio.h>
#include <stdlib.h>
#include "ft_list.h"

void	ft_list_remove_if(t_list **begin_list,
			void *data_ref, int (*cmp)(), void (*free_fct)(void *));
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

int	ft_strcmp(char *s1, char *s2)
{
	unsigned char	*s3;
	unsigned char	*s4;

	s3 = (unsigned char *)s1;
	s4 = (unsigned char *)s2;
	while (*s3 || *s4)
	{
		if (*s3 - *s4)
			return (*s3 - *s4);
		s3++;
		s4++;
	}
	return (0);
}

void	free_fct(void *data)
{
	printf(">>> FREE <<<\n%s\n", data);
}

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[6] = {"THIRD", "THIRD", "SECOND", "SECOND", "FIRST", "FIRST"};

	list = ft_list_push_strs(6, strs);
	printf(">>>BEFORE<<<\n");
	ft_list_foreach(list, &print_data);
	ft_list_remove_if(&list, "SECOND", &ft_strcmp, &free_fct);
	printf(">>>AFTER<<<\n");
	ft_list_foreach(list, &print_data);
	return (0);
}

14. ex13) ft_list_merge

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

void	ft_list_merge(t_list **begin_list1, t_list *begin_list2);
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list1;
	t_list	*list2;
	t_list	*list3;
	char	*strs1[3] = {"THIRD", "SECOND", "FIRST"};
	char	*strs2[3] = {"THREE", "TWO", "ONE"};

	list1 = ft_list_push_strs(3, strs1);
	list2 = ft_list_push_strs(3, strs2);
	list3 = NULL;
	printf(">>>BEFORE<<<\n");
	printf(">list1<\n");
	ft_list_foreach(list1, &print_data);
	printf(">list2<\n");
	ft_list_foreach(list2, &print_data);
	printf(">list3<\n");
	ft_list_foreach(list3, &print_data);
	ft_list_merge(&list1, list2);
	ft_list_merge(&list3, list2);
	printf(">>>AFTER<<<\n");
	printf(">list1<\n");
	ft_list_foreach(list1, &print_data);
	printf(">list2<\n");
	ft_list_foreach(list2, &print_data);
	printf(">list3<\n");
	ft_list_foreach(list3, &print_data);
	return (0);
}

15. ex14) ft_list_sort

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

void	ft_list_sort(t_list **begin_list, int (*cmp)());
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

int	ft_strcmp(char *s1, char *s2)
{
	unsigned char	*s3;
	unsigned char	*s4;

	s3 = (unsigned char *)s1;
	s4 = (unsigned char *)s2;
	while (*s3 || *s4)
	{
		if (*s3 - *s4)
			return (*s3 - *s4);
		s3++;
		s4++;
	}
	return (0);
}

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[6] = {"abc", "abc", "fuBU", "nAkFEBa", "q", "XOtESWcdk"};

	list = ft_list_push_strs(6, strs);
	printf(">>>BEFORE<<<\n");
	ft_list_foreach(list, &print_data);
	ft_list_sort(&list, &ft_strcmp);
	printf(">>>AFTER<<<\n");
	ft_list_foreach(list, &print_data);
	return (0);
}

16. ex15) ft_list_reverse_fun

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

void	ft_list_reverse_fun(t_list *begin_list);
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"FIRST", "SECOND", "THIRD"};

	list = ft_list_push_strs(3, strs);
	printf(">>>BEFORE<<<\n");
	ft_list_foreach(list, &print_data);
	ft_list_reverse_fun(list);
	printf(">>>AFTER<<<\n");
	ft_list_foreach(list, &print_data);
	return (0);
}

17. ex16) ft_sorted_list_insert

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

void	ft_sorted_list_insert(t_list **begin_list, void *data, int (*cmp)());
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

int	ft_strcmp(char *s1, char *s2)
{
	unsigned char	*s3;
	unsigned char	*s4;

	s3 = (unsigned char *)s1;
	s4 = (unsigned char *)s2;
	while (*s3 || *s4)
	{
		if (*s3 - *s4)
			return (*s3 - *s4);
		s3++;
		s4++;
	}
	return (0);
}

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list;
	char	*strs[3] = {"D", "C", "A"};

	list = ft_list_push_strs(3, strs);
	printf(">>>BEFORE<<<\n");
	ft_list_foreach(list, &print_data);
	ft_sorted_list_insert(&list, "B", &ft_strcmp);
	printf(">>>AFTER<<<\n");
	ft_list_foreach(list, &print_data);
	return (0);
}

18. ex17) ft_sorted_list_merge

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

void	ft_sorted_list_merge(
			t_list **begin_list1, t_list *begin_list2, int (*cmp)());
t_list	*ft_list_push_strs(int size, char **strs);
void	ft_list_foreach(t_list *begin_list, void (*f)(void *));

int	ft_strcmp(char *s1, char *s2)
{
	unsigned char	*s3;
	unsigned char	*s4;

	s3 = (unsigned char *)s1;
	s4 = (unsigned char *)s2;
	while (*s3 || *s4)
	{
		if (*s3 - *s4)
			return (*s3 - *s4);
		s3++;
		s4++;
	}
	return (0);
}

void	print_data(void *data)
{
	printf("%s\n", data);
}

int	main(void)
{
	t_list	*list1;
	t_list	*list2;
	char	*strs1[3] = {"g", "gr2y8pUQVaPs", "sFO2rmb0MyE"};
	char	*strs2[3] = {"OV1f8YsabP", "G9gm0T", "GMejbx"};

	list1 = ft_list_push_strs(3, strs1);
	list2 = ft_list_push_strs(3, strs2);
	printf(">>>BEFORE<<<\n");
	printf(">list1<\n");
	ft_list_foreach(list1, &print_data);
	printf(">list2<\n");
	ft_list_foreach(list2, &print_data);
	ft_sorted_list_merge(&list1, list2, &ft_strcmp);
	printf(">>>AFTER<<<\n");
	ft_list_foreach(list1, &print_data);
	return (0);
}
728x90
반응형

'프로젝트 > 42Seoul' 카테고리의 다른 글

42서울 라피신 3주차 (C07~C08)  (0) 2025.04.09
42서울 라피신 BSQ  (0) 2025.04.09
42서울 라피신 2주차 (C03~C06)  (0) 2025.04.09
42서울 라피신 1주차 (Rush00)  (0) 2025.04.09
42서울 라피신 1주차 (C00~C02)  (0) 2025.04.09

관련글

티스토리툴바