C언어에서 템플릿 없이 제네릭 프로그래밍 구현하기

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

void swap(void *a, void *b, size_t size) {
    void *temp = malloc(size);
    if (!temp) return;
    memcpy(temp, a, size);
    memcpy(a, b, size);
    memcpy(b, temp, size);
    free(temp);
}

int main() {
    int x = 10, y = 20;
    double a = 3.14, b = 2.71;

    swap(&x, &y, sizeof(int));
    swap(&a, &b, sizeof(double));

    printf("Swapped int: x = %d, y = %d\n", x, y);
    printf("Swapped double: a = %.2f, b = %.2f\n", a, b);

    return 0;
}

#include <stdio.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    int x = 10, y = 20;
    double a = 3.14, b = 2.71;

    printf("Max int: %d\n", MAX(x, y));
    printf("Max double: %.2f\n", MAX(a, b));

    return 0;
}

  printf("Mixed: %f\n", MAX(5, 2.5)); // 예상치 못한 결과 발생 가능

  #define SQUARE(x) ((x) * (x))
  int val = 3;
  printf("%d\n", SQUARE(++val)); // 잘못된 결과 발생 가능

#define MAX_GENERIC(x, y) _Generic((x), \
    int: MAX_INT, \
    double: MAX_DOUBLE \
)(x, y)

int MAX_INT(int a, int b) { return (a > b) ? a : b; }
double MAX_DOUBLE(double a, double b) { return (a > b) ? a : b; }

int main() {
    int x = 10, y = 20;
    double a = 3.14, b = 2.71;

    printf("Max int: %d\n", MAX_GENERIC(x, y));
    printf("Max double: %.2f\n", MAX_GENERIC(a, b));

    return 0;
}

#include <stdio.h>
#include <math.h>

#define ABS(x) _Generic((x), \
    int: abs, \
    float: fabsf, \
    double: fabs \
)(x)

int main() {
    int i = -10;
    float f = -3.14f;
    double d = -2.718;

    printf("Abs int: %d\n", ABS(i));
    printf("Abs float: %.2f\n", ABS(f));
    printf("Abs double: %.2f\n", ABS(d));

    return 0;
}

#include <stdio.h>

#define MAX(x, y) _Generic((x), \
    int: max_int, \
    float: max_float, \
    double: max_double \
)(x, y)

int max_int(int a, int b) { return (a > b) ? a : b; }
float max_float(float a, float b) { return (a > b) ? a : b; }
double max_double(double a, double b) { return (a > b) ? a : b; }

int main() {
    int x = 10, y = 20;
    float a = 3.14f, b = 2.71f;
    double p = 5.5, q = 6.6;

    printf("Max int: %d\n", MAX(x, y));
    printf("Max float: %.2f\n", MAX(a, b));
    printf("Max double: %.2f\n", MAX(p, q));

    return 0;
}

#include <stdio.h>

// 정수 비교 함수
int compare_int(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

// 실수 비교 함수
int compare_double(const void *a, const void *b) {
    double diff = (*(double *)a - *(double *)b);
    return (diff > 0) - (diff < 0);
}

// 제네릭 비교 함수 포인터
typedef int (*CompareFunc)(const void *, const void *);

// 범용 비교 함수 실행
void execute_comparison(void *a, void *b, CompareFunc cmp, const char *type) {
    int result = cmp(a, b);
    printf("%s 비교 결과: %s\n", type, result == 0 ? "같음" : (result > 0 ? "첫 번째 값이 큼" : "두 번째 값이 큼"));
}

int main() {
    int x = 10, y = 20;
    double a = 3.14, b = 2.71;

    execute_comparison(&x, &y, compare_int, "정수");
    execute_comparison(&a, &b, compare_double, "실수");

    return 0;
}

#include <stdio.h>

// 정수 덧셈
int add_int(const void *a, const void *b) {
    return (*(int *)a + *(int *)b);
}

// 실수 덧셈
double add_double(const void *a, const void *b) {
    return (*(double *)a + *(double *)b);
}

// 제네릭 연산 실행 함수
typedef void *(*OperationFunc)(const void *, const void *);

void execute_operation(void *a, void *b, OperationFunc op, const char *type) {
    printf("%s 연산 결과: ", type);
    if (type == "정수") {
        printf("%d\n", (int)(long)op(a, b));
    } else {
        printf("%.2f\n", *(double *)op(a, b));
    }
}

int main() {
    int x = 10, y = 20;
    double a = 3.14, b = 2.71;

    execute_operation(&x, &y, (OperationFunc)add_int, "정수");
    execute_operation(&a, &b, (OperationFunc)add_double, "실수");

    return 0;
}

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

// 연산 인터페이스 정의
typedef struct {
    void *(*add)(const void *, const void *);
    void *(*subtract)(const void *, const void *);
    void (*print)(const void *);
} MathOperations;

// 정수 연산 함수
void *int_add(const void *a, const void *b) {
    int *result = malloc(sizeof(int));
    *result = (*(int *)a) + (*(int *)b);
    return result;
}

void *int_subtract(const void *a, const void *b) {
    int *result = malloc(sizeof(int));
    *result = (*(int *)a) - (*(int *)b);
    return result;
}

void int_print(const void *a) {
    printf("%d\n", *(int *)a);
}

// 실수 연산 함수
void *double_add(const void *a, const void *b) {
    double *result = malloc(sizeof(double));
    *result = (*(double *)a) + (*(double *)b);
    return result;
}

void *double_subtract(const void *a, const void *b) {
    double *result = malloc(sizeof(double));
    *result = (*(double *)a) - (*(double *)b);
    return result;
}

void double_print(const void *a) {
    printf("%.2f\n", *(double *)a);
}

// 인터페이스 객체 생성
MathOperations intOps = {int_add, int_subtract, int_print};
MathOperations doubleOps = {double_add, double_subtract, double_print};

// 실행 함수
void execute_operations(MathOperations ops, void *a, void *b) {
    void *sum = ops.add(a, b);
    void *diff = ops.subtract(a, b);

    printf("Sum: ");
    ops.print(sum);
    printf("Difference: ");
    ops.print(diff);

    free(sum);
    free(diff);
}

int main() {
    int x = 10, y = 5;
    double a = 3.14, b = 2.71;

    printf("Integer operations:\n");
    execute_operations(intOps, &x, &y);

    printf("\nDouble operations:\n");
    execute_operations(doubleOps, &a, &b);

    return 0;
}

Integer operations:
Sum: 15
Difference: 5

Double operations:
Sum: 5.85
Difference: 0.43

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

// 데이터 타입을 변경하기 쉽게 정의
typedef int DataType;

// 스택 구조체 정의
typedef struct {
    DataType *data;
    int top;
    int capacity;
} Stack;

// 스택 관련 매크로 정의
#define STACK_INIT_CAPACITY 10
#define STACK_INIT(s) (stack_init(&(s), STACK_INIT_CAPACITY))
#define STACK_PUSH(s, val) (stack_push(&(s), val))
#define STACK_POP(s) (stack_pop(&(s)))
#define STACK_TOP(s) (stack_top(&(s)))
#define STACK_FREE(s) (stack_free(&(s)))

// 스택 초기화
void stack_init(Stack *s, int capacity) {
    s->data = (DataType *)malloc(capacity * sizeof(DataType));
    s->top = -1;
    s->capacity = capacity;
}

// 스택 푸시 연산
void stack_push(Stack *s, DataType value) {
    if (s->top == s->capacity - 1) {
        s->capacity *= 2;
        s->data = (DataType *)realloc(s->data, s->capacity * sizeof(DataType));
    }
    s->data[++(s->top)] = value;
}

// 스택 팝 연산
DataType stack_pop(Stack *s) {
    if (s->top == -1) {
        printf("스택이 비어 있습니다!\n");
        exit(EXIT_FAILURE);
    }
    return s->data[(s->top)--];
}

// 스택 최상위 요소 확인
DataType stack_top(Stack *s) {
    if (s->top == -1) {
        printf("스택이 비어 있습니다!\n");
        exit(EXIT_FAILURE);
    }
    return s->data[s->top];
}

// 스택 메모리 해제
void stack_free(Stack *s) {
    free(s->data);
}

int main() {
    Stack s;
    STACK_INIT(s);

    STACK_PUSH(s, 10);
    STACK_PUSH(s, 20);
    STACK_PUSH(s, 30);

    printf("Top: %d\n", STACK_TOP(s));
    printf("Popped: %d\n", STACK_POP(s));
    printf("Popped: %d\n", STACK_POP(s));

    STACK_FREE(s);
    return 0;
}

Top: 30
Popped: 30
Popped: 20

typedef double DataType;

typedef struct {
    int id;
    char name[20];
} DataType;

void process(void *data, size_t size) {
    memcpy(buffer, data, size);  // 데이터를 복사하는 과정에서 오버헤드 발생
}

#define PROCESS(data) _Generic((data), \
    int*: process_int, \
    double*: process_double \
)(data)

void process_int(int *data) { /* 최적화된 코드 */ }
void process_double(double *data) { /* 최적화된 코드 */ }

#define SQUARE(x) ((x) * (x))

int a = 5;
int b = SQUARE(a++);  // 예상치 못한 동작 발생 (a가 두 번 증가됨)

static inline int square(int x) {
    return x * x;
}

#define ABS(x) _Generic((x), \
    int: abs, \
    double: fabs \
)(x)

#define MAX(x, y) _Generic((x), \
    int: max_int, \
    double: max_double \
)(x, y)

typedef int (*CompareFunc)(const void *, const void *);

int compare_int(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

void execute_comparison(void *a, void *b, CompareFunc cmp) {
    int result = cmp(a, b);
}

typedef struct {
    int (*add)(int, int);
    int (*subtract)(int, int);
} MathOps;

int add_int(int a, int b) { return a + b; }
int subtract_int(int a, int b) { return a - b; }

MathOps ops = {add_int, subtract_int};

int main() {
    int result = ops.add(10, 5);  // 직접 함수 호출보다 성능 저하 가능
}

typedef struct {
    char name[50];  // 50바이트
    int age;        // 4바이트 (패딩 발생 가능)
    double score;   // 8바이트 (정렬 문제 발생 가능)
} Student;

typedef struct {
    double score;   // 8바이트 (첫 번째 정렬)
    int age;        // 4바이트
    char name[50];  // 50바이트 (뒤쪽 배치)
} Student;

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

// 정수 비교 함수
int compare_int(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

// 실수 비교 함수
int compare_double(const void *a, const void *b) {
    double diff = (*(double *)a - *(double *)b);
    return (diff > 0) - (diff < 0);
}

int main() {
    int int_arr[] = {42, 23, 4, 16, 8, 15};
    double double_arr[] = {3.14, 2.71, 1.61, 4.67, 2.98};

    int int_size = sizeof(int_arr) / sizeof(int_arr[0]);
    int double_size = sizeof(double_arr) / sizeof(double_arr[0]);

    // 정수 배열 정렬
    qsort(int_arr, int_size, sizeof(int), compare_int);
    printf("Sorted integers: ");
    for (int i = 0; i < int_size; i++) {
        printf("%d ", int_arr[i]);
    }
    printf("\n");

    // 실수 배열 정렬
    qsort(double_arr, double_size, sizeof(double), compare_double);
    printf("Sorted doubles: ");
    for (int i = 0; i < double_size; i++) {
        printf("%.2f ", double_arr[i]);
    }
    printf("\n");

    return 0;
}

Sorted integers: 4 8 15 16 23 42
Sorted doubles: 1.61 2.71 2.98 3.14 4.67

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

#define DEFINE_LIST(type) \
typedef struct { \
    type *data; \
    size_t size; \
    size_t capacity; \
} List_##type; \
\
void init_##type(List_##type *list, size_t capacity) { \
    list->data = (type *)malloc(capacity * sizeof(type)); \
    list->size = 0; \
    list->capacity = capacity; \
} \
\
void push_##type(List_##type *list, type value) { \
    if (list->size == list->capacity) { \
        list->capacity *= 2; \
        list->data = (type *)realloc(list->data, list->capacity * sizeof(type)); \
    } \
    list->data[list->size++] = value; \
} \
\
void print_##type(List_##type *list) { \
    for (size_t i = 0; i < list->size; i++) { \
        printf("%d ", list->data[i]); \
    } \
    printf("\n"); \
}

// 정수형 리스트 생성
DEFINE_LIST(int)

int main() {
    List_int list;
    init_int(&list, 5);

    push_int(&list, 10);
    push_int(&list, 20);
    push_int(&list, 30);

    printf("List contents: ");
    print_int(&list);

    free(list.data);
    return 0;
}

List contents: 10 20 30

#include <stdio.h>

#define min(x, y) _Generic((x), \
    int: min_int, \
    double: min_double \
)(x, y)

int min_int(int a, int b) { return (a < b) ? a : b; }
double min_double(double a, double b) { return (a < b) ? a : b; }

int main() {
    int a = 10, b = 20;
    double x = 3.14, y = 2.71;

    printf("Min int: %d\n", min(a, b));
    printf("Min double: %.2f\n", min(x, y));

    return 0;
}

Min int: 10
Min double: 2.71