C) C언어로 자바 입출력 따라하기!

C 언어 로 자바 입출력 문을 구현 해보도록 하자

 

먼저 main.h 를 만든뒤 코드를 작성하자

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

#ifndef _MAIN_H
#define _MAIN_H

#define import extern
#define final const
#define null NULL
#define false 0
#define true 1

typedef char *String;
typedef char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef uint8_t boolean;

#pragma pack(push, 1)
typedef struct _System{
    struct _OUT_{
        void (*print)(const String, ...);
        void (*println)(const String, ...);
    }out;
}Sys;
#pragma pack(pop)

#pragma pack(push, 1)
typedef struct _Scanner{
    char (*nextChar)(void);
    int8_t (*nextByte)(void);
    int16_t (*nextShort)(void);
    int32_t (*nextInt)(void);
    int64_t (*nextLong)(void);
    uint8_t (*nextUByte)(void);
    uint16_t (*nextUShort)(void);
    uint32_t (*nextUInt)(void);
    uint64_t (*nextULong)(void);
    boolean (*nextBoolean)(void);
    float (*nextFloat)(void);
    double (*nextDouble)(void);
    String (*next)(void);
    String (*nextLine)(void);
}Scanner;
#pragma pack(pop)

#endif

main.h 에는 클래스 원형을 구조체와 함수포인터로 만들어 준다.

 

이제 Systemout.c 파일을 만들자

#include "main.h"

void print(const String format, ...) {
	va_list ap;char buf[4096];
    va_start(ap, format);
    vsprintf(buf, format, ap);
    va_end(ap);
    fprintf(stdout, "%s", buf);
}
void println(const String format, ...) {
	va_list ap;char buf[4096];
    va_start(ap, format);
    vsprintf(buf, format, ap);
    va_end(ap);fprintf(stdout, "%s\n", buf);
}

Sys System = {print, println};

main.h 에 인클루드한 stdarg.h 를 사용하여 커스텀print 들을 구현한뒤 Sys System 으로 선언한뒤 print, println 을 함수포인터에 대입한다.

 

이제 Scanner.c 를 만들자

#include "main.h"

char nextChar(void){
    char c;
    scanf("%c", &c);
    getchar();
    return c;
}

int8_t nextByte(void){
    uint8_t b;
    scanf("%hhd", &b);
    getchar();
    return b;
}

int16_t nextShort(void){
    uint16_t s;
    scanf("%hd", &s);
    getchar();
    return s;
}

int32_t nextInt(void){
    uint32_t i;
    scanf("%d", &i);
    getchar();
    return i;
}

int64_t nextLong(void){
    uint64_t l;
    scanf("%lld", &l);
    getchar();
    return l;
}

uint8_t nextUByte(void){
    uint8_t b;
    scanf("%hhu", &b);
    getchar();
    return b;
}

uint16_t nextUShort(void){
    uint16_t s;
    scanf("%hu", &s);
    getchar();
    return s;
}

uint32_t nextUInt(void){
    uint32_t i;
    scanf("%u", &i);
    getchar();
    return i;
}

uint64_t nextULong(void){
    uint64_t l;
    scanf("%llu", &l);
    getchar();
    return l;
}

boolean nextBoolean(void){
    String s = (String)malloc(sizeof(char) * 5);
    scanf("%s", s);
    if(atoi(s) >= 1 || strcmp(s, "true") == 0){
        free(s);
        return true;
    }else{
        free(s);
        return false;
    }
}

float nextFloat(void){
    float f;
    scanf("%f", &f);
    getchar();
    return f;
}

double nextDouble(void){
    double d;
    scanf("%lf", &d);
    getchar();
    return d;
}

String next(void){
    String s = (String)calloc(0, sizeof(char) * 1000);
    scanf("%s", s);
    getchar();
    String str = s;
    return str;
}

String nextLine(void){
    String s = (String)calloc(0, sizeof(char) * 1000);
    scanf("%[^\n]", s);
    getchar();
    String str = s;
    return str;
}

Scanner sc = {
    nextChar,
    nextByte,
    nextShort,
    nextInt,
    nextLong,
    nextUByte,
    nextUShort,
    nextUInt,
    nextULong,
    nextBoolean,
    nextFloat,
    nextDouble,
    next,
    nextLine
};

Scanner 의 기능들을 구현한뒤 Scanner 의 함수포인터에 대입을 해준다.

 

마지막으로 ScannerTest.c 파일을 만든뒤 간단하게 테스트를 해보자

#include "main.h"

import Sys System;
import Scanner sc;

int main(void){
    System.out.print("int8_t: ");
    int8_t a = sc.nextByte();
    System.out.print("int16_t: ");
    int16_t b = sc.nextShort();
    System.out.print("int32_t: ");
    int32_t c = sc.nextInt();
    System.out.print("int64_t: ");
    int64_t d = sc.nextLong();
    System.out.print("uint8_t: ");
    int8_t e = sc.nextUByte();
    System.out.print("uint16_t: ");
    uint16_t f = sc.nextUShort();
    System.out.print("uint32_t: ");
    uint32_t g = sc.nextUInt();
    System.out.print("uint64_t: ");
    uint64_t h = sc.nextULong();
    System.out.print("boolean: ");
    boolean i = sc.nextBoolean();
    System.out.print("char: ");
    char j = sc.nextChar();
    System.out.print("float: ");
    float k = sc.nextFloat();
    System.out.print("double: ");
    double l = sc.nextDouble();
    System.out.print("String: ");
    String m = sc.next();
    System.out.print("String with space: ");
    String n = sc.nextLine();

    System.out.println(" ");
    System.out.println("int8_t: %d", a);
    System.out.println("int16_t: %d", b);
    System.out.println("int32_t: %d", c);
    System.out.println("int64_t: %lld", d);
    System.out.println("uint8_t: %u", e);
    System.out.println("uint16_t: %u", f);
    System.out.println("uint32_t: %u", g);
    System.out.println("uint64_t: %llu", h);
    System.out.println("boolean: %s", i ? "true" : "false");
    System.out.println("char: %c", j);
    System.out.println("float: %f", k);
    System.out.println("double: %f", l);
    System.out.println("String: %s", m);
    System.out.println("String with space: %s", n);

    free(m);
    free(n);

    return 0;
}

다른 파일에 있는 기능들을 사용하기위해 extern 을 import 로 매크로 정의한뒤 System 과 Scanner 을 import 한다.

그리고 입력 받은뒤 간단하게 출력하는예제를 작성 해보았다.

 

이제 터미널에 다음과 같은 명령어들을 입력해보자

gcc -c Systemout.c
gcc -c Scanner.c
gcc -c ScannerTest.c
gcc -o Scanner Systemout.o Scanner.o ScannerTest.o
.\Scanner

이렇게 터미널에 입력하면 간단한 예제가 실행됀다.