Rootable의 개발일기

HTTP 요청과 응답을 다루는 클래스

dev-rootable — Tue, 21 Oct 2025 16:56:39 +0900

References: Google Gemini

스프링에서 HTTP 요청과 응답을 다루는 대표적인 클래스로

InputStream/OutputStream: 바이너리 데이터를 직접 다루는 가장 낮은 레벨의 추상화
@RequestBody/@ResponseBody: 문자열(JSON/XML)을 객체로 자동 변환하는 중간 레벨의 추상화
HttpEntity: HTTP 헤더, 상태 코드, 바디를 모두 포함하는 메시지 전체를 다루는 가장 높은 레벨의 추상화

InputStream/OutputStream (원시 스트림)

java.io의 클래스로 HTTP Body의 데이터를 원시 바이트(byte) 스트림으로 다룸

처리 방식(스트리밍): 데이터를 청크(chunk) 단위로 조금씩 읽고 씀(전체 데이터를 메모리에 올리지 않음)
자동 변환: 전혀 없음, 개발자가 직접 바이트를 읽어 파일로 저장하거나 파일에서 바이트를 읽어 응답으로 쏴줘야 함
주 사용처: 대용량 파일 업로드 및 다운로드 시 메모리 초과(OutOfMemoryError)를 방지하기 위함

@RequestBody/@ResponseBody (자동 변환 애노테이션)

메서드 파라미터나 반환 값에 붙이는 Annotation

처리 방식(버퍼링): HTTP Body의 내용을 한 번에 전부 읽어서 메모리에 올린(버퍼링) 후 처리
자동 변환
- @RequestBody: 요청 body의 JSON/XML ➡ Java 객체 (HttpMessageConverter, 주로 Jackson)
- @ResponseBody: 메서드가 반환하는 Java 객체 ➡ JSON/XML
주 사용처: 대부분의 REST API에서 JSON 데이터를 객체로 주고 받을 때 사용

HttpEntity/ResponseEntity (HTTP 메시지 전체)

HTTP 요청/응답 전체를 감싸는 클래스(객체)

처리 방식(버퍼링): HTTP Body의 내용을 한 번에 전부 읽어서 메모리에 올린(버퍼링) 후 처리
특징
- HttpEntity<T>: HTTP 헤더와 바디를 함께 다룰 때 사용
- ResponseEntity<T>: HttpEntity를 상속 받아, 응답 상태 코드, 헤더, 바디를 모두 제어 가능
자동 변환: T 제네릭 타입에 대해 @RequestBody/@ResponseBody와 동일하게 자동 변환을 지원
주 사용처: HTTP 상태 코드를 명시적으로 반환하거나, 응답에 커스텀 헤더를 추가해야 할 때 사용

퀵 정렬(Quick Sort)

dev-rootable — Mon, 21 Apr 2025 14:40:41 +0900

퀵 정렬이란

하나의 리스트를 피벗(pivot)을 기준으로 하나는 pivot보다 작은 값들의 부분리스트, 하나는 pivot보다 큰 값들의 부분리스트로 정렬한 뒤, 각 부분리스트에 대해 재귀적으로 정렬하는 방법

분할 정복(Divide and Conquer) 알고리즘

퀵 정렬은 기본적으로 '분할 정복' 알고리즘을 기반으로 정렬되는 방식이다. 다만, 병합 정렬(Merge Sort)과 다른 점은 병합 정렬은 하나의 리스트를 '절반' 으로 나누어 분할 정복을 하고, 퀵 정렬은 피벗(pivot)을 기준으로 분할 정복을 하기 때문에 하나의 리스트에 대해 비균등하게 나뉠 수 있다는 점이다.

일반적인 성능: 퀵 정렬 > 병합 정렬

퀵 정렬은 '비교 정렬' 이며, 정렬의 대상이 되는 데이터 외에 추가적인 공간을 필요로 하지 않으므로 '제자리 정렬(in-place sort)' 이라고도 한다. 또한, 두 개의 부분 리스트를 만들 때 서로 떨어진 원소끼리 교환이 일어나므로 '불안정정렬(Unstable Sort)' 알고리즘이기도 하다.

정렬 과정

피벗 선택
피벗을 기준으로 왼쪽은 피벗보다 큰 값, 오른쪽은 피벗보다 작은 값을 탐색
양 방향에서 찾은 두 원소를 교환
왼쪽에서 탐색하는 위치와 오른쪽에서 탐색하는 위치가 엇갈리지 않을 때까지 2번으로 돌아가 위 과정을 반복
엇갈린 기점을 기준으로 두 개의 부분 리스트로 나누어 1번으로 돌아가 해당 부분 리스트의 길이가 1이 아닐 때까지 1번 과정을 반복(Divide: 분할)
인접한 부분리스틑끼리 병합 (Conqure: 정복)

왼쪽 피벗 선택 방식 (Lomuto 방식)

Ref: https://st-lab.tistory.com/250

public class QuickSort {

    public static void sort(int[] A) {
        l_pivot_sort(A, 0, A.length - 1);
    }

    public static void l_pivot_sort(int[] A, int lo, int hi) {
        if (lo >= hi) return;

        int pivot = partition(A, lo, hi);

        l_pivot_sort(A, lo, pivot - 1); //왼쪽 부분 리스트 정복
        l_pivot_sort(A, pivot + 1, hi); //오른쪽 부분 리스트 정복
    }

    public static int partition(int[] A, int left, int right) {
        int lo = left;
        int hi = right;
        int pivot = A[left];

        while (lo < hi) {
            while (A[hi] > pivot && lo < hi) hi--; //우측부터 pivot 보다 작은 값 찾기
            while (A[lo] <= pivot && lo < hi) lo++; //좌측부터 pivot 보다 큰 값 찾기
            swap(A, lo, hi);
        }

        swap(A, left, lo);
        return lo;
    }

    public static void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }

}

오른쪽 피벗 선택 방식 (Lomuto 방식)

Ref: https://st-lab.tistory.com/250

public class QuickSort {

    public static void sort(int[] A) {
        r_pivot_sort(A, 0, A.length - 1);
    }

    public static void r_pivot_sort(int[] A, int lo, int hi) {
        if (lo >= hi) return;

        int pivot = partition(A, lo, hi);

        r_pivot_sort(A, lo, pivot - 1); //왼쪽 부분 리스트 정복
        r_pivot_sort(A, pivot + 1, hi); //오른쪽 부분 리스트 정복
    }

    public static int partition(int[] A, int left, int right) {
        int lo = left;
        int hi = right;
        int pivot = A[right];

        while (lo < hi) {
            while (A[lo] < pivot && lo < hi) lo++; //좌측부터 pivot 보다 큰 값 찾기
            while (A[hi] >= pivot && lo < hi) hi--; //우측부터 pivot 보다 작은 값 찾기
            swap(A, lo, hi);
        }

        swap(A, right, hi);
        return hi;
    }

    public static void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }

}

중간 피벗 선택 방식 (Hoare 방식)

이미 피벗 기준으로 양쪽이 분할돼 있으므로, 피벗을 다시 옮길 필요 없다.
➡ 마지막에 pivot을 swap하지 않으므로, 두 포인터가 같아질 때 바로 swap 후 종료

Ref: https://st-lab.tistory.com/250

public class QuickSort {

    public static void sort(int[] A) {
        m_pivot_sort(A, 0, A.length - 1);
    }

    public static void m_pivot_sort(int[] A, int lo, int hi) {
        if (lo >= hi) return;

        int pivot = partition(A, lo, hi);

        m_pivot_sort(A, lo, pivot - 1); //왼쪽 부분 리스트 정복
        m_pivot_sort(A, pivot + 1, hi); //오른쪽 부분 리스트 정복
    }

    public static int partition(int[] A, int left, int right) {
        int lo = left;
        int hi = right;
        int pivot = A[(left + right) / 2];

        while (lo <= hi) {
            while (A[lo] < pivot) lo++;
            while (A[hi] > pivot) hi--;

            if (lo <= hi) {
                swap(A, lo, hi);
                lo++;
                hi--;
            }
        }

        return hi;
    }

    public static void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }

}

시간 복잡도

O(NlogN)의 시간복잡도

Ref: https://st-lab.tistory.com/250

이상적으로 피벗이 중앙에 위치되어 리스트를 절반으로 나눈다고 할 때, N개의 데이터가 있는 리스트를 1개까지 쪼개어 트리로 나타내게 되면 Binary Tree 형태로 나온다. 알고리즘에서 피벗을 잡고 큰 요소와 작은 요소를 각 끝단에서 시작하여 탐색하며 만족하지 못하는 경우 swap 한다. 이는 현재 리스트의 요소들을 탐색하기 때문에 O(N)이다.

좀 더 자세하게 말하자면 i번째 레벨에서 노드의 개수가 2^i개이고, 노드의 크기(=한 노드에 들어있는 원소의 개수)는 N/2^i개다. 이를 곱하면 한 레벨에서 비교 작업에 대한 시간복잡도는 O(2^i * N/2^i)이고 곧 O(N)이다. 그리고 O(N)의 비교 작업을 트리의 높이인 logN-1번 수행하므로 O(NlogN)의 시간복잡도를 갖는 것을 알 수 있다. 퀵 정렬은 정렬된 상태의 배열을 정렬하고자 할 때 최악의 성능을 보인다.

❓ 퀵 정렬이 빠른 이유

적은 오버헤드와 참조 지역성(캐시 효율성)

1. 상수 요인(Constant Factor) 이 작다. (적은 오버헤드)

빅오(Big-O) 표기법은 데이터의 양(N)이 커질 때의 성장률을 나타낼 뿐, 실제 연산 횟수에 곱해지는 상수는 무시한다. 퀵 정렬의 핵심 연산(inner loop)은 단순한 비교와 값 교환(swap)으로만 이루어져 있어 매우 가볍다.

퀵 정렬: while (arr[i] < pivot) 처럼 단순 비교만 반복
병합 정렬: 정렬된 두 배열을 합치기 위해 추가적인 메모리 공간을 할당하고, 데이터를 복사하는 과정에서 상대적으로 무거운 작업(오버 헤드)이 발생

즉, 같은 O(NlogN) 이라도 실제 기계가 실행하는 명령어의 수가 퀵 정렬이 훨씬 적기 때문에 더 빠르다.

2. 참조 지역성(Locality of Reference) 원리를 잘 활용한다. (캐시 효율성)

CPU는 메모리(RAM)에서 데이터를 가져올 때, 속도가 훨씬 빠른 캐시 메모리에 해당 데이터와 그 주변 데이터를 함께 저장한다. 그 후, 필요한 데이터가 캐시에 있으면(Cache Hit) 메모리까지 가지 않고 매우 빠르게 작업을 처리한다.

퀵 정렬: 배열의 특정 구간(파티션) 내에서 순차적으로 데이터를 접근하며 정렬 ➡ 한번 캐시에 올라온 데이터를 계속 활용할 가능성이 높아 캐시 히트율(Cache Hit Ratio)이 매우 높음
다른 정렬 방식: 데이터 접근이 상대적으로 여기저기 흩어져 있어 캐시 효율성이 떨어질 수 있음

"퀵 정렬은 한 페이지에 있는 글자들을 순서대로 읽는 것, 병합 정렬은 책의 10페이지와 100페이지를 번갈아 보는 것"

Hoare vs Lomuto 비교

pivot의 처리 방식과 분할 효율성 차이

Lomuto 방식은 피봇을 정하고 그보다 작은 값을 왼쪽으로, 큰 값을 오른쪽으로 보내 피봇의 최종 위치를 정합니다. 이 방식은 직관적이지만, 이미 정렬된 배열 같은 특정 경우에 성능이 크게 저하될 수 있다.

반면, Hoare 방식은 배열 양 쪽 끝에서부터 탐색하여 피봇보다 크거나 작은 값을 교환해 나간다. 이 방식은 최종 위치가 정해지진 않지만, 일반적으로 Lomuto 방식보다 비교와 교환 횟수가 적어 더 빠르고 효율적이다.

정리

평균적으로 매우 빠른 속도

시간 복잡도가 O(NlogN) 이다. 다른 O(NlogN) 정렬 알고리즘 대비 오버헤드가 적고 캐시 효율성(참조 지역성)이 높아 실제 실행 속도가 가장 빠른 정렬 알고리즘 중 하나다.

제자리 정렬(In-place sort)

정렬을 위한 별도의 추가 메모리가 필요하지 않음. 이는 대용량 데이터를 정렬할 때 큰 장점

최악의 경우 성능 저하(O(N^2))

pivot 이 한 쪽으로 치우치게 선택될 경우 (이미 정렬된 배열) 시간 복잡도가 O(N^2)으로 성능이 급격히 나빠질 수 있음

불안정 정렬(Unstable sort)

값이 같은 데이터들의 기존 순서가 정렬 후에도 유지되지 않을 수 있음. 따라서 데이터의 기존 순서가 중요한 경우에는 사용하기 부적합.

References:

https://st-lab.tistory.com/250

자바 [JAVA] - 퀵 정렬 (Quick Sort)

[정렬 알고리즘 모음] 더보기 1. 계수 정렬 (Counting Sort) 2. 선택 정렬 (Selection Sort) 3. 삽입 정렬 (Insertion Sort) 4. 거품 정렬 (Bubble Sort) 5. 셸 정렬 (Shell Sort) 6. 힙 정렬 (Heap Sort) 7. 합병(병합) 정렬 (Merge

st-lab.tistory.com

단체 채팅 프로그램 개발

dev-rootable — Fri, 12 Jul 2024 17:29:42 +0900

Ref: https://www.pexels.com/ko-kr/photo/whatsapp-46924/

Ubuntu 환경에서 단체 채팅방을 C와 MySQL을 통해 구현했다. MySQL은 채팅 내용을 저장하는 용도로 사용한다.

기능 목록

모든 사용자에게 채팅 메시지가 전달된다.
최초 접속하면 최근 10개의 채팅을 볼 수 있다.
채팅 내용은 MySQL에 저장한다.

클라이언트 동작 흐름

MySQL 커넥션 초기화 및 연결
서버와 통신할 소켓 생성
소켓에 연결할 서버 주소 정보 바인딩
서버에 연결 요청
DB로부터 최근 10개 레코드 조회 후 각 클라이언트 화면에 출력
데이터 전송
1. 시간 정보, 사용자 이름, 채팅 메시지 등을 포맷팅 하여 서버에 전송
2. 클라이언트가 'exit' 명령을 입력하면 로그아웃으로 간주하여 close 수행
데이터 수신
1. 서버에서 작성한 메시지가 있다면 읽어온 후 출력

서버 동작 흐름

MySQL 커넥션 초기화 및 연결
듣기 소켓 생성
듣기 소켓에 서버 주소 정보 바인딩
클라이언트 요청 대기
Connect를 시도한 클라이언트 요청을 받으면 클라이언트 소켓 생성
클라이언트가 전송한 메시지를 모든 클라이언트에게 보낸 후 저장
접속한 클라이언트 IP와 Port 등 주소 정보 출력
접속한 클라이언트에게 로그인 메시지 전달
채팅 데이터를 DB에 INSERT 쿼리
종료를 요청한 클라이언트 소켓 제거
서버 소켓 종료 및 MySQL 연결 해제

들어가기 전 알아두기

✍ 소켓 통신 과정

❓ 소켓을 어떻게 접근할까

소켓은 socket descriptor 라는 식별자를 통해 접근할 수 있다. 해당 값은 int 형으로 socket() 함수를 통해 소켓을 생성하면 반환 값으로 얻을 수 있다. 이는 UNIX에서 파일 open 후 file descriptor를 얻는 것과 같은 기능이다.

❓ 소켓 바인딩하는 방법

객체지향 프로그래밍에서는 바인딩을 위해 생성자를 사용하고, 그 생성자의 본체가 클래스다. 소켓은 sockaddr이라는 구조체가 본체이고, 해당 구조체에 바인딩하기 위해 sockaddr_in 구조체를 사용한다. 그 이유는 sockaddr 구조체 내에 주소를 담는 char 배열이 있는데 이것을 좀 더 세분화해서 나눈 것이 sockaddr_in이기 때문이다. 즉 구조적으로 허용된 작업인 것이다.

sockaddr 구조체는 리눅스/유닉스 시스템일 경우 <sys/socket.h> 헤더 파일, 윈도우는 <winsock.h> 헤더 파일을 통해 사용할 수 있다.

sys/socket.h: 리눅스/유닉스 시스템에서 소켓의 주소를 저장하거나 표현하는 데 사용하는 구조체를 제공

sockaddr_in 구조체 내에 주소 체계, 주소, 포트 등의 멤버에 값을 입력하고, socket 식별자에 바인딩하면 된다. 이 작업을 위한 bind() 함수는 아래와 같이 구성되어 있다.

int bind(int sockfd, struct sockaddr *addr, int addr_len)

여기서 주소를 바인딩하기 위해 arpa/inet.h 라는 헤더 파일이 필요하다.

arpa/inet.h: 숫자로 IP 주소를 조작하는 기능들을 정의한 헤더 파일

헤더 파일 내에 htonl(), htons(), ntohl(), ntohs() 등의 함수가 있는데 이들은 소켓을 통해 다른 기종 간에 데이터를 송수신할 수 있도록 데이터를 변환한다.

❓ 소켓 통신에서 주소를 변환하는 이유

Big Endian과 Little Endian

소켓으로 통신을 할 때 TCP/IP와 호스트는 Byte를 저장하는 순서가 다르다.

저장할 때 상위 바이트, 즉 큰 쪽을 먼저 저장하는 것을 빅 엔디안(Big Endian),
저장할 때 하위 바이트, 즉 작은 쪽을 먼저 저장하는 것을 리틀 엔디안(Little Endian)이라고 한다.

여기서 먼저 저장한다는 것은 앞 주소에 둔다는 것을 의미한다.

예를 들어, 컴퓨터에 int형 4 byte 데이터 0x010203040을 저장한다고 했을 때, 다음과 같이 저장한다.

출처: https://softtone-someday.tistory.com/20

가령 TCP/IP에 주소 정보를 전송한다고 했을 때, 네트워크에서는 빅 엔디안으로 통일하기 때문에 <arpa/inet.h>와 같은 헤더 파일의 함수를 통해 별도 처리하여 전송해야 한다.

❓ accept() 함수를 수행한 후 소켓이 다시 반환되는 이유

서버는 listen() 함수를 통해 클라이언트의 연결 요청을 대기한다. 클라이언트 요청 정보는 시스템 내부적으로 관리되는 큐에 쌓이게 되는데, 큐에 대기하고 있는 요청을 꺼내와서 연결을 완료하는 작업을 accept() 함수가 수행한다.

여기서 듣기 소켓과 연결 소켓이라는 개념을 알아야 한다.

socket() 함수를 통해 생성된 소켓은 연결 요청을 확인하는 또는 듣는 역할만 수행한다. 그래서 연결 요청을 받으면 즉시 수신 대기열로 넘겨 다음 요청을 대기한다. 그렇다면 accept() 함수를 통해 반환된 소켓은 무엇일까?

출처: https://codingfarm.tistory.com/538

위 그림을 보면 연결 요청 대기열이라는 것이 있는데 이것이 요청 대기 큐이다. 여기서 accept() 함수가 첫 번째 요청을 꺼내는데 이 소켓이 바로 클라이언트 소켓이다. 즉, 실제 클라이언트와 통신하는 소켓이라는 것이다. 왜 이렇게 소켓을 분리했을까. 그것은 통신하는 중에도 다른 클라이언트의 요청을 받아들일 수 있도록 하기 위함이다.

❓ 멀티 스레딩은 왜 필요한가

데이터를 송수신하기 위해서 read() 와 write() 함수를 사용한다. 여기서 write()는 데이터를 보내는 주체가 자기 자신이다. 그래서 보낼 데이터의 양을 알 수 있지만 read() 함수는 그렇지 않다. 즉, 한번 실행하면 언제 끝날지 모르는 상태가 되는 것이다.

read() 함수가 종료되는 순간은 클라이언트에서 close() 를 수행하여 서버에 EOF를 보냈을 때이다. 결론적으로 모든 클라이언트를 위해 시스템을 동기화할 수 없다. 그래서 송수신 작업을 하는 함수를 스레드에 올려 비동기적으로 작업해야 여러 클라이언트의 요청을 처리하고 응답할 수 있다. 유닉스 계열 POSIX 시스템에서는 pthread.h 헤더 파일을 제공하여 이를 지원한다.

pthread.h: POSIX Thread의 약자로 유닉스계열 POSIX 시스템에서 병렬적으로 작동하는 소프트웨어를 작성하기 위해 제공하는 API (멀티 스레딩)

구현

‍ Server, Client > MySQL 접속

먼저 MySQL 을 사용하기 위해 <mysql/mysql.h> 헤더 파일을 넣어야 한다. 실습 환경인 Ubuntu에서 MySQL을 사용하기 위해서는 MySQL을 설치하고 계정을 생성하는 등의 작업이 필요하다. 아래 링크를 참고하면 도움이 될 것이다.

https://olppaemmit.tistory.com/27

[Linux] Ubuntu에 MySQL 설치 및 사용(외부 접속)

1. MySQL 설치 2. conf 파일 수정 3. port 열어주기 4. MySQL 시작 5. MySQL 접속 6. MySQL 권한 부여 7. VirtualBox에서 포트포워딩 8. MySQL 외부접속 1. MySQL 설치하기 sudo apt-get install mysql-server 2. conf 파일 수정(port

olppaemmit.tistory.com

또한 C 에서 사용하는 MySQL 명령어는 아래 링크를 참고하면 도움이 될 것이다.

https://onecellboy.tistory.com/161

[C 언어] mysql c언어 api라이브러리 사용법 - 펌

출처 : http://koronaii.tistory.com/194 MySQL C API 1) my_ulonglong mysql_affected_rows(MYSQL* mysql) INSERT, UPDATE, DELETE 등의 query로 영향을 받은 ROW의 수를 리턴한다. 2) void mysql_close(MYSQL* mysql) 서버와의 연결을 종료한다

onecellboy.tistory.com

...
#include <mysql/mysql.h>

MYSQL *con;                   // SQL connection
MYSQL_RES *sql_result = NULL; // SQL 응답
MYSQL_ROW sql_row;            // SQL 결과 배열

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    pthread_t send_thread, recv_thread; // 송신 스레드, 수신 스레드
    void *thread_return;                // pthread_join에 사용
    int str_len;
    
    // MYSQL
    con = mysql_init(NULL);

    if (con == NULL)
    {
        fprintf(stderr, "%s\n", mysql_error(con));
        exit(1);
    }

    if (mysql_real_connect(con, "localhost", "user1", "0000", "chatdb", 3306, NULL, 0) == NULL)
    {
        finish_with_error(con);
    }
    
    ...

C에서 MySQL이라는 타입으로 connection을 생성할 수 있다. 이를 초기화하고 생성한 계정을 통해 접속하는 코드다.

‍ Client > 소켓 생성

int main(int argc, char *argv[])
{
    ...
    sock = socket(PF_INET, SOCK_STREAM, 0); // 소켓 생성
    
    ...

'sock' 이라는 Socket 식별자에 socket() 함수를 통해 생성한 소켓을 저장한다. PF_INET은 프로토콜을 지정한다는 것인데 리눅스에서는 AF_INET과 서로 같은 상수를 갖고 있어 구분하지 않아도 된다. SOCK_STREAM은 TCP 통신을 의미하며, 0은 별도 프로토콜을 지정하지 않겠다는 의미다.

‍ Client > 서버 정보 바인딩

int main(int argc, char *argv[])
{
    ...

    // 연결할 서버 정보 할당
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));
    
    ...

inet_addr() 함수와 htons() 함수를 통해 네트워크 바이트 순서에 맞게 주소를 변환한다.

Server > 듣기 소켓 생성

...

#include <pthread.h>

/*
여러 명의 클라이언트가 접속하므로 클라이언트 소켓은 배열
멀티스레드 시, clnt_cnt와 clnt_socks 에 여러 스레드가 접속할 수 있기 때문에
두 변수를 사용하는 영역은 임계 영역
*/
int clnt_cnt = 0; // 접속한 클라이언트 수
int clnt_socks[MAX_CLNT];
pthread_mutex_t mtx; // mutex 선언 (스레드끼리 전역변수 동시 사용 방지)

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock; // serv_sock(듣기 소켓), clnt_sock(연결 소켓)
    struct sockaddr_in serv_addr, clnt_addr;
    pthread_t tid; // thread 선언
    socklen_t clnt_addr_size;
    
    ...
    
    pthread_mutex_init(&mtx, NULL); // mutex 생성

    if ((serv_sock = socket(PF_INET, SOCK_STREAM, 0)) == -1) // 듣기 소켓 생성
    {
        error_handling("socket() error");
    }
    
    ...

듣기 소켓을 생성하기 앞서 mutex를 알아야 한다.

mutex는 pthread에서 지원하는 기능으로 여러 스레드를 실행하는 환경에서 자원에 대한 접근 제한을 위한 동기화를 지원한다. 클라이언트 요청을 비동기적으로 처리하지만 모든 클라이언트가 사용하는 변수는 동기화를 해야 동시 수정으로 인한 일관성 오류를 막을 수 있다. 바로 클라이언트의 수를 카운팅하는 clnt_cnt와 앞서 그림에서 본 클라이언트 소켓들을 저장하는 clnt_socks 배열이 대상이다. 위 코드에서는 사용할 mutex를 초기화하고 있다.

Server > 듣기 소켓에 서버 주소 바인딩

int main(int argc, char *argv[])
{
    ...

    // 주소 정보 바인딩
    printf("set server addr...\n");
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));
    
    printf("binding...\n");
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) // 소켓과 주소 정보 결합
    {
        error_handling("bind() error");
    }
    
    ...

이처럼 서버 주소를 바인딩하면 클라이언트가 요청한 서버 주소와 동일한 주소인지 듣기 소켓이 식별한다.

Server > 클라이언트 연결 요청 대기

int main(int argc, char *argv[])
{
    // 5는 큐의 크기
    // 웹 서버같이 수 천명의 클라이언트로 바쁠 경우, 15로 잡는 경우가 보통
    if (listen(serv_sock, 5) == -1)
    {
        error_handling("listen() error");
    }

    printf("waiting...\n");
    
    ...

큐의 크기를 설정하고 클라이언트 요청을 대기한다.

‍ Client > 서버에 연결 요청

int main(int argc, char *argv[])
{
    ...
    
    // 서버에 연결 요청
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        perror("connect");
        return -1;
    }
    
    ...

connect() 함수를 통해 소켓 식별자에 서버 정보를 바인딩한 구조체(serv_addr)의 주소를 넘겼다. 만약 음수가 나온다면 연결에 실패한 것이다.

Server > 클라이언트 소켓 생성

...

#include <pthread.h>

int main(int argc, char *argv[])
{
    ...
    
    while (1)
    {
        clnt_addr_size = sizeof(clnt_addr);
        // clnt_addr -> 연결된 클라이언트의 주소 정보
        if ((clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size)) < 0)
        {
            error_handling("accept() error");
        }

        printf("[NOW] accept\n");
        
        pthread_mutex_lock(&mtx);           // 전역 변수 사용을 위해 mutex 락
        clnt_socks[clnt_cnt++] = clnt_sock; // 소켓 배정
        pthread_mutex_unlock(&mtx);         // mutex 언락
        
    ...

듣기 소켓을 통해 적재해 둔 연결 요청으로부터 accept() 함수를 통해 클라이언트 요청을 생성했다. 그 후에 클라이언트 소켓을 저장하는 clnt_socks 배열에 현재 클라이언트 소켓을 저장했다.

clnt_socks 배열은 클라이언트 전역 변수이므로 pthread_mutex_lock()과 pthread_mutex_unlock() 안에서 작업해야 한다.

‍ Client > 최근 채팅 10개 로그 출력 요청

MYSQL *con;                   // SQL connection
MYSQL_RES *sql_result = NULL; // SQL 응답
MYSQL_ROW sql_row;            // SQL 결과 배열

int main(int argc, char *argv[])
{
    ...

    if (mysql_query(con, "SELECT * FROM CHAT ORDER BY date DESC LIMIT 10") != 0) // 최근 10개 레코드 조회
        finish_with_error(con);

    sql_result = mysql_store_result(con); // 쿼리 결과 호출

    while ((sql_row = mysql_fetch_row(sql_result)) != NULL)
    {
        printf("%s : %s\n", sql_row[0], sql_row[1]);
    }
    
    ...

클라이언트는 쿼리를 통해 최근 10개 레코드를 요청했다. 테이블 상태는 아래와 같다.

MYSQL_RES 타입 변수를 통해 저장된 쿼리 결과를 받을 수 있다. 그 후에 결과를 모두 fetch 하여 MYSQL_ROW 변수로 받으면 튜플 단위로 필드마다 배열로 저장된다. 이를 출력했다.

로그 데이터 형식

‍ 데이터 전송

...

#include <pthread.h>

#define BUF_SIZE 100
#define NAME_SIZE 30
#define TIME_SIZE 100

void *send_msg(void *arg);
void *recv_msg(void *arg);
void finish_with_error(MYSQL *con);

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    pthread_t send_thread, recv_thread; // 송신 스레드, 수신 스레드
    void *thread_return;                // pthread_join에 사용
    int str_len;

    ...

    // 송신과 수신을 수행할 두 스레드 생성
    // 연결 요청 대상인 서버는 동일하므로 매개변수는 sock으로 동일
    pthread_create(&send_thread, NULL, send_msg, (void *)&sock);
    pthread_create(&recv_thread, NULL, recv_msg, (void *)&sock);

    // 스레드 종료 대기
    pthread_join(send_thread, NULL);
    pthread_join(recv_thread, NULL);

    close(sock); // 클라이언트 연결 종료

    mysql_free_result(sql_result); // SQL 응답 포인터 해제

    return 0;
}

데이터를 송수신하는 작업은 클라이언트끼리 동기화할 수 없다. 따라서 pthread_create()를 통해 데이터를 전송하고 수신하는 함수를 스레드에 올려서 동작하도록 했다.

스레드는 종료되어도 즉시 메모리 자원이 해제되지 않는다. 이를 위해 pthread_join() 함수를 사용한다. 이 함수를 만나면 스레드는 자원을 해제하기 때문에 메모리 누수가 발생하지 않으려면 스레드마다 해당 함수를 사용해야 한다. pthread_join()의 영향을 받는 스레드는 기본 스레드인 joinable 스레드다.

...
#include <time.h>

char msg[BUF_SIZE];
char name[NAME_SIZE] = "[DEFAULT]"; // 채팅창에 보여질 이름의 형태(20자 제한)
char logout[] = "님이 로그아웃했습니다.\n";

...

void *send_msg(void *arg)
{
    int sock = *((int *)arg);                        // void descriptor -> int 변환
    char name_msg[TIME_SIZE + NAME_SIZE + BUF_SIZE]; // 사용자 ID와 메시지를 합칠 것임
    char logout_msg[NAME_SIZE + strlen(logout)];     // 사용자 ID와 로그아웃 메시지를 합칠 것임
    char local_date_time[TIME_SIZE];                 // 포맷팅한 시간 정보
    time_t now = time(NULL);                         // 현재 시간
    struct tm *t = localtime(&now);                  // 시간 포맷팅

    while (1)
    {
        fgets(msg, BUF_SIZE, stdin); // 사용자 입력을 msg에 저장

        asctime_r(t, local_date_time); // 현재 시간 갱신

        if (!strcmp(msg, "exit\n"))
        {
            sprintf(logout_msg, "%s %s", name, logout);  // (사용자 ID + 로그아웃 메시지) 를 버퍼에 저장
            write(sock, logout_msg, sizeof(logout_msg)); // 서버로 전송하여 모든 클라이언트에 뿌림

            close(sock); // 서버에 EOF 보냄
            exit(1);
        }

        // 생성된 name_msg를 출력
        sprintf(name_msg, "%s > %s %s", local_date_time, name, msg); // ID가 joo이고 메시지가 "Hi" 라면, [joo] Hi

        write(sock, name_msg, sizeof(name_msg)); // 서버로 채팅을 보냄
    }

    return NULL;
}

사용자 입력을 fgets()를 통해 받는다. fgets()는 공백이나 '\n'에 상관없이 마지막에 NULL('\0')만 붙이기 때문에 가장 안전하다고 판단하여 사용했다.

현재 시간을 채팅에 포함하기 위해 time.h 헤더 파일을 사용했다. 해당 헤더 파일에서 제공하는 time() 함수를 사용하면 현재 시간을 얻을 수 있다. 앞서 sockaddr 구조체처럼 시간도 tm이라는 구조체로 받을 수 있다. 그러면 아래와 같은 tm 필드에 값이 적절히 바인딩된다.

tm 구조체

asctime()이라는 함수는 이 내용을 토대로 시간 정보를 좀 더 알아보기 좋게 포맷팅 해준다. asctime_r() 함수는 이 기능에 자동으로 시간을 갱신해 주는 기능이 추가되었다.

동작 방식은 채팅 출력문을 포맷팅 한 후 서버 소켓으로 write() 하는 것이다. 그리고 'exit'이라는 문자열을 적으면 로그아웃 즉 EOF를 전송하도록 했다.

Server > 클라이언트가 전송한 메시지를 모든 클라이언트에 전송하고 저장

int main(int argc, char *argv[])
{

    while (1)
    {
        ...

        pthread_create(&tid, NULL, handle_clnt, (void *)&clnt_sock); // handle_clnt를 작업하는 스레드 생성
        pthread_detach(tid);                                         // 해당 스레드 분리
        printf("accepted host(IP: %s, Port: %d)\n", inet_ntoa(clnt_addr.sin_addr), ntohs(serv_addr.sin_port));

        mysql_free_result(sql_result); // SQL 응답 포인터 해제
    }
    
    close(serv_sock);
    mysql_close(con);

    return 0;
}

서버도 클라이언트 요청을 처리하는 함수를 pthread를 통해 생성한 스레드에 올렸다. read() 작업이 종료된 후 close()를 요청한 클라이언트의 클라이언트 소켓을 close() 한 후 해당 스레드를 분리한다. 마찬가지로 스레드를 통해 동작하므로 detach 아래 출력문이 클라이언트가 접속하자마자 출력된다.

char login[] = "로그인을 완료하였습니다. 로그아웃 명령은 'exit' 입니다.\n";

...

void *handle_clnt(void *arg)
{
    int clnt_sock = *((int *)arg); // void descriptor -> int 변환
    int str_len = 0;
    char msg[BUF_SIZE];
    char query[QUERY_SIZE + BUF_SIZE];
    char pk[QUERY_SIZE];

    send_msg_me(clnt_sock, login, strlen(login));

    /*
    클라이언트에서 보낸 메시지 받음
    클라이언트에서 EOF를 보내 str_len 이 0이 될때까지 반복
    EOF는 클라이언트에서 소켓을 close 했을 때 보냄
    즉, 클라이언트가 접속을 하고 있는 동안에는 while 문을 벗어나지 않는다.
    */
    while ((str_len = read(clnt_sock, msg, sizeof(msg))) != 0)
    {
        send_msg(msg, str_len); // 접속한 모두에게 메시지 보내기

        // escape single quote
        for (int i = 0; i < str_len; i++)
        {
            if (msg[i] == 39)
            {
                for (int j = str_len; j > i; j--)
                {
                    msg[j] = msg[j - 1];
                }
                i += 2;
            }
        }

        now = time(NULL); // 현재 시간

        sprintf(pk, "%ld", now);
        sprintf(query, "INSERT INTO CHAT VALUES('%s', '%s')", pk, msg); // 채팅 쿼리 생성
        if (mysql_query(con, query))                                    // 채팅 저장
            finish_with_error(con);
    }

    // while 문을 탈출 -> 현재 담당하는 소켓의 연결이 끊김

    ...

}

// 접속한 모두에게 메시지 보내기
void send_msg(char *msg, int len)
{
    pthread_mutex_lock(&mtx); // 전역 변수 사용을 위해 mutex 락
    for (int i = 0; i < clnt_cnt; i++)
        write(clnt_socks[i], msg, len); // 모든 클라이언트 소켓에 메시지 전달

    pthread_mutex_unlock(&mtx); // mutex 언락
}

// 접속한 대상에만 메시지 보내기
void send_msg_me(int clnt_sock, char *msg, int len)
{
    write(clnt_sock, msg, len); // 접속 클라이언트 소켓에 메시지 전달
}

...

클라이언트가 전송한 데이터와 클라이언트 소켓을 처리하는 함수다.

send_msg_me() 함수를 통해 접속한 클라이언트에게 로그인 메시지를 전송한다.

서버는 read() 함수를 통해 클라이언트 측에서 write() 한 데이터가 있는지 주시한다. 그러다가 데이터가 들어오면 모든 클라이언트에게 입력한 내용을 보여준다. 이는 설계상 단체 채팅 프로그램이기 때문이다. 모든 클라이언트에게 메시지를 전송하려면 클라이언트 소켓 목록을 가져와서 반복문을 통해 메시지를 보여줘야 한다. 이 작업은 클라이언트 전역 변수를 사용하기 때문에 mutex 락을 걸고 수행해야 한다.

앞서 테이블의 필드를 보면 Primary Key로 'date'가 지정되어 있었다. 이는 현재 시간을 10자리 정도의 숫자로 저장한 것이며, 기본키 역할을 한다. 이렇게 완성된 하나의 튜플을 INSERT문을 통해 MySQL에 로그로서 저장한다.

while 문을 탈출하게 되면 EOF를 받은 것이며, 연결 종료 작업을 수행해야 한다. 그래서 다시 mutex를 열어 해당 클라이언트 소켓을 제거하는 작업을 수행했다.

‍ 데이터 수신

void *recv_msg(void *arg)
{
    int sock = *((int *)arg);                        // void descriptor -> int 변환
    char name_msg[TIME_SIZE + NAME_SIZE + BUF_SIZE]; // 사용자 ID와 메시지를 합칠 것임
    int str_len = 0;

    while (1)
    {
        str_len = read(sock, name_msg, sizeof(name_msg) - 1); // 서버에서 들어온 메시지 수신

        name_msg[str_len] = 0; // 버퍼 맨 마지막 값 NULL

        fputs(name_msg, stdout); // 받은 메시지 출력 (서버에서 write 한 메시지)
    }

    return NULL;
}

서버에서 write() 한 데이터가 있다면 이를 읽어 출력한다.

Server > 종료를 요청한 클라이언트 소켓 제거

    // while 문을 탈출 -> 현재 담당하는 소켓의 연결이 끊김

    pthread_mutex_lock(&mtx); // 전역 변수 사용을 위해 mutex 락
    // 현재 스레드에서 담당하는 소켓(disconnected) 삭제
    for (int i = 0; i < clnt_cnt; i++)
    {
        if (clnt_sock == clnt_socks[i]) // 현재 담당하는 클라이언트 소켓의 descriptor를 찾으면
        {
            while (i++ < clnt_cnt - 1) // 해당 위치부터 클라이언트 소켓 1칸씩 당기기
                clnt_socks[i] = clnt_socks[i + 1];

            break;
        }
    }

    clnt_cnt--;                 // 클라이언트 수 감소
    pthread_mutex_unlock(&mtx); // mutex 언락

    close(clnt_sock); // 서버의 스레드에서 담당하는 클라이언트 소켓 종료
    
    return NULL;
} //handle_clnt 종료

Server > MySQL 해제 후 서버 소켓 종료

int main(int argc, char *argv[])
{

    while (1)
    {
        ...

        pthread_detach(tid);                                         // 해당 스레드 분리
        printf("accepted host(IP: %s, Port: %d)\n", inet_ntoa(clnt_addr.sin_addr), ntohs(serv_addr.sin_port));

        mysql_free_result(sql_result); // SQL 응답 포인터 해제
    }
    
    close(serv_sock);
    mysql_close(con);

    return 0;
}

결과물

전체 코드:

https://github.com/wndudrla1011/project-c-2024/tree/main/chat

project-c-2024/chat at main · wndudrla1011/project-c-2024

Contribute to wndudrla1011/project-c-2024 development by creating an account on GitHub.

github.com

채팅 프로그램

접속 후 로그

References:

https://softtone-someday.tistory.com/20

[개념정리] 빅엔디안(Big Endian)과 리틀엔디안(Little Endian)

통신을 하다 보면 통신 패킷이 반대로 나갈 때가 있습니다. 예를 들면 1 2 3 4를 보냈는데 막상 받는 쪽에서 들어온 패킷은 4 3 2 1인 거죠 이는 컴퓨터 CPU의 데이터를 저장하는 순서에서 발생하는

softtone-someday.tistory.com

https://dev-rootable.tistory.com/163

소켓 프로그래밍

소켓이란 네트워크에서 데이터를 송수신할 수 있도록 네트워크 환경에 연결할 수 있게 만들어진 연결부 네트워크에 연결하기 위한 소켓은 정해진 규약, 즉 통신을 위한 프로토콜에 맞게

dev-rootable.tistory.com

소켓 프로그래밍

dev-rootable — Mon, 8 Jul 2024 15:11:01 +0900

소켓이란

네트워크에서 데이터를 송수신할 수 있도록 네트워크 환경에 연결할 수 있게 만들어진 연결부

네트워크에 연결하기 위한 소켓은 정해진 규약, 즉 통신을 위한 프로토콜에 맞게 만들어져야 한다. 보통 OSI 7 계층 중 4 계층인 TCP 상에서 동작하는 소켓을 주로 사용하며, 이를 TCP 소켓 또는 TCP/IP 소켓이라고 부른다. 마찬가지로 UDP에서 동작하는 소켓을 UDP 소켓이라고 부른다.

소켓은 크게 프로토콜, IP 주소, 포트로 정의된다.

용어 정리

프로토콜(Protocol)
컴퓨터 사이에서 메시지를 주고 받는 데 필요한 양식, 약속이나 규약

IP 주소(IP Address)
각 장치(호스트)를 식별하기 위한 고유 주소. 송신자와 수신자를 식별

포트(Port)
IP 주소를 통해 도착한 호스트에서 어떤 프로세스와 통신할지에 대한 정보. 즉, 프로세스를 구분하는 번호

소켓 프로그래밍

소켓 프로그래밍 개요

데이터를 주고 받기 위해서는 소켓의 연결 과정이 선행되어야 하고, 그 과정에서 연결 요청과 수락이 각각 클라이언트 소켓과 서버 소켓의 역할이다.

클라이언트 소켓은 IP 주소와 포트 번호를 통해 서버 소켓에게 연결을 시도하고, 서버 소켓은 어떤 연결 요청(포트 번호로 식별)을 받아들일지 미리 시스템에 등록하여 요청이 수신되었을 때 해당 요청을 처리한다.

소켓 연결이 완료된 후 클라이언트 소켓과 서버 소켓은 데이터를 주고받는데, 직접 데이터를 주고받는 것이 아니라 서버 소켓은 클라이언트 소켓의 연결 요청을 받아들이는 역할만 수행할 뿐이다. 직접적인 데이터 송수신은 서버 소켓의 연결 요청 수락 결과로 만들어지는 새로운 소켓을 통해 처리된다.

Creating a socket

데이터를 송수신하기 위한 통로(소켓) 생성

소켓 통신을 하기 위해서는 먼저 소켓을 생성해야 한다.

#incldue <sys/socket.h>

int socket(int domain, int type, int protocol);

위와 같은 socket 함수를 통해 소켓을 생성한다.

socket 함수 파라미터

domain
통신에 사용되는 protocol family를 지정한다.

protocol family
소켓을 생성할 때 이 소켓이 어떤 프로토콜을 사용해 통신을 할지 정하는 정보

출처: https://seongmok.com/43

type
SOCK_STREAM은 TCP 통신 체계에서 사용되고, SOCK_DGRAM은 UDP 통신 체계에서 사용된다.
두 가지 타입을 가장 많이 사용하며, 각 방식은 해당 통신 체계의 성질과 호환된다.

protocol
해당 소켓에서 사용되는 별도의 protocol이 필요할 경우 protocol 파라미터로 지정해 주면 된다. 필요하지 않을 경우 보통 0을 전달한다.

socket()은 system call로 반환 값은 socket descriptor이다. 이때 소켓 생성에 실패하면 -1을 반환한다.

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>

int sockfd;

if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    //print "socket error + the error message"
    perror("socket error");
    exit(1);
}

최초 소켓이 생성되는 시점에는 연결 대상에 대한 어떠한 정보도 담겨 있지 않다. 따라서 연결 대상(IP:Port)을 지정하고 연결 요청을 전달하기 위해서는 connect() API를 호출해야 한다.

Binding the local address ( bind() )

소켓에 주소를 할당하기 위한 시스템 콜

시스템에서 네트워크 관련 프로세스가 TCP 또는 UDP와 같은 프로토콜을 사용한다면 각 소켓은 시스템이 관리하는 포트(0 ~ 65535) 중 하나의 포트 번호를 사용하게 된다. 여기서 서로 다른 소켓이 같은 포트 번호를 사용하는 일이 생길 수 있어 운영체제는 내부적으로 포트 번호와 소켓 연결 정보를 관리한다. 그리고 bind() API는 해당 소켓이 지정된 포트 번호를 사용할 것이라는 것을 운영체제에 요청하는 역할을 한다. 만약 지정된 포트 번호를 다른 소켓이 사용하고 있다면 bind() API는 에러를 리턴한다.

서버 소켓은 고정된 포트 번호를 사용하고 그 포트 번호로 클라이언트의 연결 요청을 받아들인다. 그래서 운영체제가 특정 포트 번호를 서버 소켓이 사용하도록 만들기 위해 소켓과 포트 번호를 결합해야 하는데 이 때 사용하는 API가 bind()인 것이다.

✅ bind API

int bind(int sockfd, struct sockaddr *addr, int addr_len)

파라미터 설명

int sockfd: socket() 결과로 반환된 socket descriptor
struct sockaddr *addr: socket의 구조체 포인터 (자신의 address + port number)
int addr_len: 구조체의 길이

성공 시 0을 리턴, 실패 시 -1을 리턴

✅ 소켓 구조체 (sockaddr)

#define <netinet/in.h>

struct sockaddr {
    u_char sa_len; //length : used in kernel
    u_short sa_family; //address family
    char sa_data[14]; //address
}

✅ sockaddr_in

sa_data [14]를 조금 더 세분화해서 나눈 sockaddr_in

//<netinet/in.h> 헤더 파일에 정의되어 있음

struct sockaddr_in {
    u_char sin_len; //length
    u_short sin_family; //AF_INET
    u_short sin_port; //port number (2 byte)
    struct in_addr sin_addr; //IP address (4 byte)
    char sin_zero[8]; //unused (8byte), fill the zero
}

struct in_addr {
    u_long s_addr; //32 bit IP address
}

출처: https://seongmok.com/43

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MYPORT 50000

int sockfd;
struct sockaddr_in my_addr; //socket 구조체 선언

if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) { //소켓 생성
    //print "socket error + the error message"
    perror("socket error");
    exit(1);
}

memset(&my_addr, 0, sizeof(my_addr)); //socket 구조체 초기화

my_addr.sin_family = AF_INET; //address family(PF_INET과 동일)

/*
자신의 포트 번호를 htons를 통해 변환
htons는 host에서 사용하는 number를 network에서 사용가능하도록 short하게 변환함
*/
my_addr.sin_port = htons(MYPORT);

/*
INADDR_ANY는 현재 나의 주소 반환
htonl은 host에서 사용하는 주소를 network에서 사용가능하도록 long하게 변환함
*/
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(my_addr)) < 0) {
    perror("bind error");
    exit(1);
}

htonl(), htons(), ntohl(), ntohs()

htons() - Host to Network Short
htonl() - Host to Network Long
ntohs() - Network to Host Short
ntohl() - Network to Host Long

소켓을 통해 다른 기종 간에 데이터를 송수신할 때, Host System의 Byte Order에 맞게 데이터를 변환해 주기 위해 사용된다. 반드시 네트워크에 보내기 전에 네트워크 바이트 순서로 바꿔서 보내야 한다.

sin_port, sin_addr은 네트워크 바이트 순서로 기록하지만 sin_family는 그렇지 않다. sin_port와 sin_addr은 캡슐화되어 네트워크로 전송되어야 하는 변수인 것이다. 따라서 Network-Byte-Order(Big Endian)이어야 한다. 반면, sin_family는 시스템 내부에서 커널에 의해서만 사용되는 변수이며 네트워크로 전송되지 않으므로 Host-Byte Order(Little Endian)로 기록되어야 하는 것이다.

htonl 함수
32 bit Little Endian ➡ Big Endian (in TCP/IP)로 변환하는 함수이다.
sockaddr_in 구조체에 저장되기 전에 32 bit로 처리되는 IP Address를 Big Endian으로 변환하는데 주로 사용된다.

htons 함수
32 bit Little Endian ➡ Big Endian (in TCP/IP) 로 변환하는 함수이다.
sockaddr_in 구조체에 저장되기 전에 32 bit로 처리되는 Port Number를 Big Endian으로 변환하는데 주로 사용된다.

Name-to-Address Conversion

INADDR_ANY와 같이 주소를 바로 넘겨줄 수 있지만, 이름만 알고 있을 때 그 이름을 주소로 변경하는 과정이 필요하다. 또한 반대로 주소를 호스트 이름으로 변경할 수도 있다.

gethostbyname(): hostname ➡ address
gethostbyaddr(): address ➡ hostname

IP Address Manipulation

위 함수를 통해 hostname을 binary한 주소로 바꿨다면 우리가 알아볼 수 있게 변환할 수 있어야 할 것이다. 이를 Dotted decimal이라고 한다. (ex. 11111111.00000000.00000000.00000001 ➡ 255.0.0.1)

char *inet_ntoa(struct in_addr address); //IP address -> dotted decimal

/*
dotted decimal -> IP address (return 0 if error)
req: *cp <- dotted decimal
res: *inp <- IP address
*/
char inet_aton(const char *cp, struct in_addr *inp);

u_long inet_addr(char *dottedAddress); //dotted decimal -> directly return IP address (return -1 if error)

connect

서버 소켓으로 연결 요청

connect() API는 IP 주소와 포트 번호로 식별되는 대상으로 연결 요청을 보낸다. connect() API는 Block 방식으로 동작하기 때문에 연결 요청에 대한 결과가 결정되기 전에는 실행이 끝나지 않는다.

#include <sys/socket.h>

int connect(int sockfd, struct sockaddr *addr, int addr_len);

성공 시 0, 실패 시 -1을 리턴한다.

3-way-handshaking 과정을 통한 커넥션을 요청하기 때문에 TCP에 사용된다.

아주 가끔 UDP에도 사용된다고 한다.
sendto() 함수를 사용할 때 목적지 정보를 매번 넣기 번거로워 최초 connect()를 하여 얻은 정보를 계속 사용한다. 이때 실제 데이터 전송은 없다.

소켓 기술자(socket descriptor)

UNIX에서 파일을 열면(open)하면 int 타입의 정수를 리턴하는데 이를 파일 기술자(file descriptor)라고 하며, 파일 기술자를 통해 open된 파일에 접근할 수 있다. 즉, 해당 파일에 대한 포인터를 가지는 것이다.

출처: http://jkkang.net/unix/netprg/chap2/net2_1.html

파일 기술자는 기술자 테이블의 index 번호다. 기술자 테이블이란 현재 open되어 있는 파일의 정보들로 구성된 구조체를 가리키는 포인터들로 구성된 테이블이다.

프로그램에서 소켓을 개설하면 파일 기술자와 똑같은 기능을 하는 소켓 기술자가 리턴된다.

API 호출이 성공하면 send() / recv() API를 통해 데이터를 주고받을 수 있다.

#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#define DEST_IP "10.12.110.57"
#define DEST_PORT 23

int sockfd;
struct sockaddr_in dest_addr;
if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    /* error */
}

memset(&dest_addr, 0, sizeof(dest_addr)); //init memory to 0
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(DEST_PORT);
dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);

if(connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) < 0) {
    close(sockfd);
    return -1;
}

Listen

클라이언트 연결 요청 대기

서버 소켓에 포트 번호를 결합(bind)하고 나면, 서버 소켓을 통해 클라이언트의 연결 요청 수신을 기다리게 되는데 이 역할을 listen() API가 수행한다. 연결 요청이 수신되면 대기 상태를 종료하고 리턴한다.

int listen(int sd, int backlog);

sd: socket descriptor
backlog: connection 할 때 Q에 몇 개까지의 요청을 pending 상태로 놓을 것인지에 대한 사이즈 (usually 5)

성공 시 0을, 실패 시 -1 리턴

연결 요청을 기다리는 함수이기 때문에 TCP에만 사용된다.

listen() API 가 성공하더라도 요청 성공 또는 실패에 대한 정보만 있고 요청에 대한 정보는 들어 있지 않다. 대신 클라이언트 연결 요청에 대한 정보는 시스템 내부적으로 관리되는 Queue에 쌓이게 되는데, 이 시점에서 클라이언트와의 연결은 아직 완전히 연결되지 않은 대기 상태이다. 대기 중인 연결 요청을 Queue로부터 꺼내와서 연결을 완료하기 위해서는 accept() API를 호출해야 한다.

Accept

최종 연결 요청을 받아들이는 역할

연결 요청을 Q로부터 꺼내와서 소켓 간 연결을 수립하는데, 이 때 데이터 통신을 위해 연결되는 소켓은 앞 과정에서 사용한 소켓이 아니라 accept() API 내부에서 새로 만들어진 소켓이다.

새로 만들어진 소켓과 포트 번호를 바인딩하고 클라이언트의 요청을 대기하기 위해 생성된 요청 대기 큐에 쌓여 있는 첫 번째 연결 요청이 매핑된다.

여기까지가 서버 소켓의 역할이고, 서버 소켓의 남은 일은 다른 연결 요청을 처리하기 위해 다시 대기(listen)하거나 서버 소켓을 닫는(close) 것뿐이다.

int accept(int sd, struct sockaddr *addr, int *addrlen);

성공 시 새로운 socket descriptor 반환, 실패 시 -1 반환

sd: 생성된 소켓의 식별 번호
addr: accept 성공 시, 연결된 클라이언트의 주소 정보가 담기는 구조체
addrlen: sockaddr 구조체 크기

반환 값은 socket 함수로 받은 듣기 소켓과는 전혀 다른 별개의 소켓이다.

듣기 소켓: 연결 요청을 확인하는(듣는) 역할만 수행, 연결 요청을 받으면 즉시 수신 대기열로 넘겨 다음 요청을 대기
연결 소켓: 실제 클라이언트와 통신

즉, 연결을 받아들이는 과정과 통신하는 과정이 분리된다. 따라서, 듣기 소켓과 연결소켓의 구분을 통해, 통신하는 중에도 다른 클라이언트의 연결 요청을 받아들일 수 있다.

이를 구현하기 위해 주로 멀티 프로세스나 멀티 스레딩 프로그래밍이 사용된다.

출처: https://codingfarm.tistory.com/538

< socket() ~ accept()> server code

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define MYPORT 50000

int main()
{
    int sockfd;
    struct sockaddr_in server_addr, client_addr;
    int sin_size;
    
    sockfd = socket(PF_INET, SOCK_STREAM, 0); //socket()
    
    //setting server_addr
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(MYPORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
    bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)); //bind()
    
    listen(sockfd, 5); //listen()
    
    sin_size = sizeof(client_addr);
    
    //change a socket
    new_fd = accept(sockfd, (struct sockaddr *)&client_addr, &sin_size); //accept()
    return 0;
}

데이터 송수신 ( send() / recv() ) - TCP

연결된 소켓을 통해 데이터를 보낼 때는 send(), 데이터를 받을 때는 recv() API를 사용한다. 두 API도 Block 방식으로 동작한다. 그래서 0을 리턴하면 상대방 측에서 커넥션을 close 한 것이다.

int send(int sockfd, const void *msg, int len, int flag)

write()와 동일 (flag는 보통 0으로 쓴다.)

성공 시 writing 한 바이트 수를 리턴, 실패 시 -1 리턴

int recv(int sockfd, void *buf, int len, unsigned int flag)

read()와 동일 (flag는 보통 0으로 쓴다.)

성공 시 읽은 바이트 수를 리턴, 실패 시 -1 리턴

read ↔ recv, write ↔ send 사이에 차이는 없다. 자신의 OS에서 지원해 주는 함수를 사용하면 된다.

send()의 경우 데이터를 보내는 주체가 자기 자신이기 때문에 얼마만큼의 데이터를 보낼 것인지를 알 수 있다. 하지만 데이터를 수신하는 경우 통신 대상이 언제, 어떤 데이터를 보낼 것인지를 특정할 수 없기 때문에 recv() API가 한번 실행되면 언제 끝날지 모르는 상태가 된다.

따라서 데이터 수신을 위한 recv() API는 별도의 스레드에서 실행한다. 소켓의 생성과 연결이 완료된 후, 새로운 스레드를 하나 만든 다음 그곳에서 recv()를 실행하고 데이터가 수신되길 기다리는 것이다.

close and shutdown

데이터 송수신이 완료되고 더 이상 송수신이 필요 없게 되면 close() API를 통해 소켓을 닫는다.

소켓 연결이 종료된 후 다시 데이터를 주고받고 싶다면 또 한 번의 소켓 생성과 연결 과정을 통해 소켓 데이터를 송수신할 수 있는 상태가 되어야 한다.

int close(int sockfd)

TCP에서 클라이언트가 연결을 끊고 싶을 때 사용한다.

클라이언트가 close() 상태일 때

서버에서 recv() ➡ return 0
서버에서 send() ➡ return -1 (error)
- Client error signal: SIGPIPE
- Server error signal: EPIPE

int shutdown(int sockfd, int how)

연결을 끊는 것이 아닌 보내거나 받는 기능만 닫는 것이다. 이는 how에서 판단한다.

how에 올 수 있는 값은 다음과 같다.

출처: https://seongmok.com/43

close()와 SHUT_RDWR의 차이는 소켓의 생존 여부다. close는 소켓 정보가 소멸하지만 SHUT_RDWR는 소켓 정보가 유지된다.

References:

https://velog.io/@dltmdrl1244/%EC%86%8C%EC%BC%93%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D1-%EC%86%8C%EC%BC%93%EC%9D%98-%EC%9D%B4%ED%95%B4%EC%99%80-%EA%B8%B0%EB%B3%B8-%EB%BC%88%EB%8C%80#%EC%86%8C%EC%BC%93%EC%9D%98-%EC%A3%BC%EC%86%8C-%ED%95%A0%EB%8B%B9-%EB%B0%8F-%EC%97%B0%EA%B2%B0--bind-

https://velog.io/@dogfootbirdfoot/SocketProgramming#4-2-%EC%84%9C%EB%B2%84-%EC%86%8C%EC%BC%93-%EB%B0%94%EC%9D%B8%EB%94%A9--bind-

https://seongmok.com/43

http://jkkang.net/unix/netprg/chap2/net2_1.html

https://blog.naver.com/lovinghc/30031089847

https://codingfarm.tistory.com/538

C 계산기 구현

dev-rootable — Fri, 5 Jul 2024 17:12:19 +0900

학습 목표

✔ 연결 리스트 자료 구조 사용
✔ 구조체 노드 생성
✔ 포인터를 통한 데이터 접근
✔ 계산기 구현

✍ 연결 리스트

여러 데이터를 앞 뒤로 포인터를 통해 사슬처럼 연결할 수 있는 자료구조

단순 연결 리스트(Singly Linked List)

이중 연결 리스트(Doubly Linked List)

특징

연속되는 항목들이 포인터로 연결되어 있음
마지막 항목은 NULL을 가리킴
프로그램이 수행되는 동안 크기가 동적으로 변함
메모리 공간 낭비가 적지만 포인터 메모리가 필요함
배열보다 데이터 추가와 삭제, 삽입 등 용이
순차 접근을 해기 때문에 탐색 속도가 떨어짐
데이터는 객체 단위로 추가함
head의 링크를 끊어버리면 전체 노드를 삭제할 수 있음

구현

✅ 선언

typedef struct
{
    double item;
    struct Node *ptr;
} Node;

위와 같은 식으로 선언할 수 있다. 하지만 아직 메모리를 할당하지 않았기 때문에 실제로 생성되지는 않은 상태다.

✅ Head 선언

가장 첫 번째 노드가 될 head 노드부터 생성한다.

Node *head = NULL;

✅ 메모리 및 데이터 할당

head = (Node *)malloc(sizeof(Node));
head->item = 10;
head->ptr = NULL;

✅ 연결

Node *node = NULL;
node = (Node *)malloc(sizeof(Node));
node->item = 20;
node->ptr = NULL;

head->ptr = node;

현재 상태

✍ 구조체

다양한 데이터 조합을 지원하기 위해 변수들의 집합을 하나의 타입으로 나타낸 것

✅ 정의와 선언

struct Product
{
    int id;
    char *name;
    int price;
};

또는 아래와 같이 익명으로 선언한 후 뒤에 typedef를 통해 별칭을 달아줄 수도 있다.

typedef struct
{
    int id;
    char *name;
    int price;
}Product;

✅ 구조체 멤버 접근

int main()
{
    Product product1;

    // 초기화 - 방법 1
    product1.id = 1;
    product1.name = "Server";
    product1.price = 50000;

    // 초기화 - 방법 2
    Product product2 = {.id = 1, .name = "Server", .price = 50000};

    // 초기화 - 방법 3
    Product product3 = {1, "Server", 50000};

    printf("id: %d\n", product1.id);
    printf("name: %s\n", product1.name);
    printf("price: %d\n", product1.price);

    return 0;
}

중첩 구조체

구조체 내 구조체를 선언할 수 있다. 본인이 설계하고자 하는 객체에 따라 사용할 수 있다.

외부 참조 구조체

struct score
{
    double math;
    double english;
    double total;
    double average;
};

struct student
{
    int no;
    struct score s;
};

int main(void)
{
    struct student stu = {20170121, {90, 80, 0, 0}};

    stu.s.total = stu.s.math + stu.s.english;
    stu.s.average = stu.s.total / 2;

    printf("학번 : %d\n", stu.no);
    printf("총점 : %lf\n", stu.s.total);
    printf("평균 : %lf\n", stu.s.average);

    return 0;
}

자기 참조 구조체

#include <stdio.h>

typedef struct student
{
    char name[20];
    int money;
    struct student *link;
} Student_List;

int main(void)
{
    Student_List stu1 = {"박효원", 5000, NULL};
    Student_List stu2 = {"라태인", 6000, NULL};
    Student_List stu3 = {"강건욱", 4000, NULL};

    stu1.link = &stu2;
    stu2.link = &stu3;

    printf("%s %d\n", stu1.name, stu1.money);
    printf("%s %d\n", stu1.link->name, stu1.link->money);
    printf("%s %d\n", stu1.link->link->name, stu1.link->link->money);

    return 0;
}

위 코드를 보면 stu1 -> stu2 -> stu3 식으로 참조를 할 수 있다. 이는 연결 리스트와 유사한 구조를 가진다.

계산기

구현 개요

1. 모든 입력 값은 노드이며, 노드들을 연결리스트로 묶음
2. Stack 구조를 사용하므로, 연결리스트에 노드가 추가될 때마다 바로 앞 노드를 가리킨다.
3. Stack 구조로 계산하기 위해서 입력된 수식을 후위변환식으로 변경한다.
4. 변환된 후위식에서 계산할 피연산자 단위를 구분하기 위해 strtok을 구현한다.
5. 계산을 통해 계산 결과를 출력한다. 이때, 소수점 3자리까지만 출력한다.

연결리스트 및 구조체 선언

typedef struct
{
    double item;
    struct Node *link;
} Node;

typedef struct
{
    Node *head;
} LinkedList;

각 노드는 item이라는 값과 이전 노드를 가리키는 link를 가진다.

LlinkedList는 초기 head 역할을 하는 구조체로 head라는 포인터를 통해 노드를 연결하고 해제한다.

또한 아래와 같이 초기화를 할 수 있다.

void init(LinkedList *L)
{
    L->head = NULL;
}

스택 관련 함수

int isEmpty(LinkedList *L)
{
    return (L->head == NULL);
}

void push(LinkedList *L, double item)
{
    Node *node = (Node *)malloc(sizeof(Node)); // 새 노드 메모리 할당

    // 기존 노드와 연결
    node->item = item;      // 노드 값 셋팅
    node->link = (L->head); // 새 노드 -> 기존 노드
    (L->head) = node;       // 맨 앞 노드이므로 head로 변경
}

double pop(LinkedList *L)
{
    if (isEmpty(L))
    {
        printf("StackIsEmpty Error\n");
        exit(1);
    }
    else
    {
        Node *node = L->head;     // node: 가장 최근에 연결된 노드
        double item = node->item; // 반환할 값
        L->head = L->head->link;  // 바로 앞에 위치한 노드가 head가 됨
        free(node);
        return item;
    }
}

double peek(LinkedList *L)
{
    if (isEmpty(L))
    {
        printf("StackIsEmpty Error\n");
        exit(1);
    }
    else
    {
        return L->head->item; // 가장 뒷 노드의 값 리턴
    }
}

push를 하게 되면 아래와 같은 그림이 된다.

push 과정

- 새 노드를 생성(메모리 할당)한다.
- 새 노드에 값을 세팅
- 새 노드는 head(앞 노드)를 가리킨다.
- 새 노드가 새로운 head가 된다.

pop 은 아래와 같이 동작한다. head를 통해 새 노드가 연결되기 때문에 head를 변경하고 메모리를 해제해 주면 된다.

pop 과정

- 기존 head의 값과 주소 저장
- head를 앞 노드로 변경
- 메모리 해제
- 값 반환

후위 변환

void toPostfix(char exp[], char postfix[])
{
    int p = 0; // p : postfix 배열 인덱스
    int len = cstrlen(exp);
    char ch;
    Node *node = NULL;

    init(&node);

    for (int i = 0; i < len; i++)
    {
        ch = exp[i];

        switch (ch)
        {
        case '*':
        case '/':
        case '+':
        case '-':
            while (!isEmpty(&node) && priority(ch) <= priority(peek(&node)))
            {
                postfix[p++] = ' ';
                postfix[p++] = pop(&node);
            }
            push(&node, ch);
            break;
        case '(':
            push(&node, ch);
            break;
        case ')':
            while (!isEmpty(&node) && peek(&node) != '(') // find '('
            {
                postfix[p++] = ' ';
                postfix[p++] = pop(&node);
            }
            pop(&node); //'(' 제거
            break;
        default:                              // digit
            if (i > 0 && exp[i - 1] - 48 < 0) // 수식 숫자 앞 연산자 -> 공백
            {
                postfix[p++] = ' ';
            }
            postfix[p++] = ch;
            break;
        }
    }

    while (!isEmpty(&node))
    {
        postfix[p++] = ' ';
        postfix[p++] = pop(&node);
    }
}

먼저 문자 배열로 받은 수식을 하나씩 처리하도록 했다.

수식은 크게 연산자, 피연산자, 괄호로 나누어 볼 수 있다.

후위표현식을 만드는 규칙은 다음과 같다.

모든 값은 공백으로 구분할 것이기 때문에 후위식 배열(postfix)에 넣기 전에 추가한다.
모든 숫자는 바로 후위식 배열에 담는다.
- 딘, 2자리 이상 숫자를 처리하기 위해 수식의 숫자 이전 자리에 연산자가 있을 때만 공백을 넣는다.
'('는 스택(연결리스트)에 담는다.
사칙 연산자는 스택이 비지 않았고, 현재 연산자 우선순위가 앞에 들어간 연산자보다 같거나 낮을 경우 앞에 들어간 연산자를 후위식 배열에 추가하고 현재 연산자를 스택에 추가한다.
- 연산자 우선순위가 높은 것이 먼저 계산되어야 하기 때문에 후위식 배열에 먼저 들어간 것이다.
')' 연산자는 '(' 연산자를 찾을 때까지 스택을 탐색하면서 연산자를 후위식 배열로 옮긴다.
- '('을 제거해야 하기 때문에 탐색 후 pop을 한번 더 수행한다.
수식의 마지막은 숫자다. 그래서 처리가 끝난 후에 스택에 연산자가 반드시 남는다.
- 반복문을 통해 남은 연산자를 후위식 배열로 옮긴다.

계산

int cstrlen(char *str)
{
    int idx = 0;
    while (str[idx] != '\0')
        ++idx;
    return idx;
}

char *cstrtok(char *postfix, char *delim)
{
    char *start = 0; // 문자열 시작 위치
    int i = 0;
    static char *tmp; // 문자열 주소 저장

    if (postfix != NULL) // 첫 토큰 받을 때
        start = postfix;
    else // 두 번째 이후 토큰 받을 때
        start = tmp;

    if (cstrlen(start) < 1) // 문자열 종료
        return NULL;

    for (i = 0; i < cstrlen(start); i++)
    {
        if (start[i] == (*delim) || start[i] == '\0')
        {
            start[i] = '\0';
            break;
        }
    }

    tmp = &start[i + 1]; // 다음 배열 시작 위치

    return start;
}

cstrtok은 strtok을 구현한 것이다.

strtok과 같이 동작하도록 처음 호출했을 때(postfix != NULL)는 첫 문자열을 가리키도록 하고, 공백 또는 NULL을 찾을 때마다 NULL로 대체한다.

start라는 포인터를 이동하면서 공백을 기준으로 나누어진 토큰을 가리킨다. tmp는 다음 토큰의 포인터를 저장하기 위한 임시 포인터다.

double calculate(char postfix[])
{
    int len = cstrlen(postfix);
    double op1 = 0.0, op2 = 0.0;
    Node *node = NULL;
    char *delim = " ";
    char *token;

    init(&node);

    token = cstrtok(postfix, delim);

    while (token != NULL)
    {
        printf("token: %s\n", token);

        if (token[0] != '*' && token[0] != '/' && token[0] != '+' && token[0] != '-')
        {
            int i = 0;
            double val = 0.0; // 두자리 수 이상 결과

            // 각 토큰 -> 스택 저장
            while (token[i] != '\0')
            {
                val = val * 10 + (token[i] - 48);
                i++;
            }

            push(&node, val);
        }

        else
        {
            op2 = pop(&node);
            op1 = pop(&node);

            switch (token[0])
            {
            case '+':
                push(&node, op1 + op2);
                break;
            case '-':
                push(&node, op1 - op2);
                break;
            case '*':
                push(&node, op1 * op2);
                break;
            case '/':
                if (op2 == 0) // 나누기 0 예외 처리
                    printf("DivideByZeroException\n");
                push(&node, op1 / op2);
                break;
            }
        }

        token = cstrtok(NULL, delim);
    }

    return pop(&node);
}

변환된 후위식은 공백을 기준으로 연산자와 피연산자가 들어 있다. 여기서 공백을 제거한 연산자와 피연산자만을 가지는 포인터가 token이다.

후위식 계산은 숫자일 때는 스택에 넣고, 연산자가 나오면 숫자를 2개 pop()하여 해당 연산자에 맞는 작업을 하면 된다. 여기서 0으로 나누는 경우를 예외 처리했고, 2자리 이상 숫자일 경우 해당 숫자를 만들도록 했다.

전체 코드

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

typedef struct
{
    double item;
    struct Node *link;
} Node;

typedef struct
{
    Node *head;
} LinkedList;

void init(LinkedList *L)
{
    L->head = NULL;
}

int isEmpty(LinkedList *L)
{
    return (L->head == NULL);
}

void push(LinkedList *L, double item)
{
    Node *node = (Node *)malloc(sizeof(Node)); // 새 노드 메모리 할당

    // 기존 노드와 연결
    node->item = item;      // 노드 값 셋팅
    node->link = (L->head); // 새 노드 -> 기존 노드
    (L->head) = node;       // 맨 앞 노드이므로 head로 변경
}

double pop(LinkedList *L)
{
    if (isEmpty(L))
    {
        printf("StackIsEmpty Error\n");
        exit(1);
    }
    else
    {
        Node *node = L->head;     // node: 가장 최근에 연결된 노드
        double item = node->item; // 반환할 값
        L->head = L->head->link;  // 바로 앞에 위치한 노드가 head가 됨
        free(node);
        return item;
    }
}

double peek(LinkedList *L)
{
    if (isEmpty(L))
    {
        printf("StackIsEmpty Error\n");
        exit(1);
    }
    else
    {
        return L->head->item; // 가장 뒷 노드의 값 리턴
    }
}

int priority(char op)
{
    switch (op)
    {
    case '(':
    case ')':
        return 0;
    case '+':
    case '-':
        return 1;
    case '*':
    case '/':
        return 2;
    }
    return -1;
}

int cstrlen(char *str)
{
    int idx = 0;
    while (str[idx] != '\0')
        ++idx;
    return idx;
}

char *cstrtok(char *postfix, char *delim)
{
    char *start = 0; // 문자열 시작 위치
    int i = 0;
    static char *tmp; // 문자열 주소 저장

    if (postfix != NULL) // 첫 토큰 받을 때
        start = postfix;
    else // 두 번째 이후 토큰 받을 때
        start = tmp;

    if (cstrlen(start) < 1) // 문자열 종료
        return NULL;

    for (i = 0; i < cstrlen(start); i++)
    {
        if (start[i] == (*delim) || start[i] == '\0')
        {
            start[i] = '\0';
            break;
        }
    }

    tmp = &start[i + 1]; // 다음 배열 시작 위치

    return start;
}

double cround(double num, int place)
{
    for (int i = 1; i < place; i++)
    {
        num *= 10;
    }

    num += 0.5;

    for (int i = 1; i < place; i++)
    {
        num /= 10;
    }

    return num;
}

void toPostfix(char exp[], char postfix[])
{
    int p = 0; // p : postfix 배열 인덱스
    int len = cstrlen(exp);
    char ch;
    Node *node = NULL;

    init(&node);

    for (int i = 0; i < len; i++)
    {
        ch = exp[i];

        switch (ch)
        {
        case '*':
        case '/':
        case '+':
        case '-':
            while (!isEmpty(&node) && priority(ch) <= priority(peek(&node)))
            {
                postfix[p++] = ' ';
                postfix[p++] = pop(&node);
            }
            push(&node, ch);
            break;
        case '(':
            push(&node, ch);
            break;
        case ')':
            while (!isEmpty(&node) && peek(&node) != '(') // find '('
            {
                postfix[p++] = ' ';
                postfix[p++] = pop(&node);
            }
            pop(&node); //'(' 제거
            break;
        default:                              // digit
            if (i > 0 && exp[i - 1] - 48 < 0) // 수식 숫자 앞 연산자 -> 공백
            {
                postfix[p++] = ' ';
            }
            postfix[p++] = ch;
            break;
        }
    }

    while (!isEmpty(&node))
    {
        postfix[p++] = ' ';
        postfix[p++] = pop(&node);
    }
}

double calculate(char postfix[])
{
    int len = cstrlen(postfix);
    double op1 = 0.0, op2 = 0.0;
    Node *node = NULL;
    char *delim = " ";
    char *token;

    init(&node);

    token = cstrtok(postfix, delim);

    while (token != NULL)
    {
        printf("token: %s\n", token);

        if (token[0] != '*' && token[0] != '/' && token[0] != '+' && token[0] != '-')
        {
            int i = 0;
            double val = 0.0; // 두자리 수 이상 결과

            // 각 토큰 -> 스택 저장
            while (token[i] != '\0')
            {
                val = val * 10 + (token[i] - 48);
                i++;
            }

            push(&node, val);
        }

        else
        {
            op2 = pop(&node);
            op1 = pop(&node);

            switch (token[0])
            {
            case '+':
                push(&node, op1 + op2);
                break;
            case '-':
                push(&node, op1 - op2);
                break;
            case '*':
                push(&node, op1 * op2);
                break;
            case '/':
                if (op2 == 0) // 나누기 0 예외 처리
                    printf("DivideByZeroException\n");
                push(&node, op1 / op2);
                break;
            }
        }

        token = cstrtok(NULL, delim);
    }

    return pop(&node);
}

int main(void)
{
    int n = 0;           // 반올림 자리
    double result = 0.0; // 계산 결과
    char *exp;           // 입력
    char postfix[MAX_SIZE] = {'\0'};
    exp = (char *)malloc(sizeof(char) * 100);

    printf("계산식을 입력한 후 Enter를 눌러주세요!\n");
    scanf("%s", exp);

    toPostfix(exp, postfix);
    printf("\nPostfix: %s\n", postfix);

    printf("몇 번째 자리에서 반올림하시겠습니까? >>>");
    scanf("%d", &n);

    result = calculate(postfix);

    printf("계산한 결과: \t%.3f\n", cround(result, n));

    return 0;
}

References:

https://velog.io/@riceintheramen/Linked-list#%EC%97%B0%EA%B2%B0-%EB%A6%AC%EC%8A%A4%ED%8A%B8%EC%9D%98-%ED%8A%B9%EC%A7%95

https://velog.io/@kysung95/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0%EB%A1%A0-C%EB%A1%9C-%EC%97%B0%EA%B2%B0%EB%A6%AC%EC%8A%A4%ED%8A%B8%EB%A5%BC-%EB%A7%8C%EB%93%A4%EC%96%B4%EB%B3%B4%EC%9E%90

https://www.tcpschool.com/c/c_struct_intro

https://wikidocs.net/12623

https://wikidocs.net/12625

왜 C언어를 사용하는가

dev-rootable — Mon, 1 Jul 2024 15:22:57 +0900

C언어의 주요 기능

저수준 메모리 접근

포인터를 통해 메모리 할당, 해제 및 데이터 조작 등의 작업을 수행할 수 있다. 이 기능은 메모리 관리가 중요한 시스템 프로그래밍과 임베디드 시스템 개발에서 큰 장점으로 작용한다.

다양한 표준 라이브러리

C 언어는 표준 입출력, 문자열 처리, 수학 연산, 파일 처리 등 다양한 기본적인 프로그래밍 작업을 지원하는 방대한 표준 라이브러리를 제공한다. 이것은 C 언어가 저수준뿐만 아니라 고수준 언어의 특징을 갖고 있어 다양한 애플리케이션 개발을 지원한다는 것을 의미한다.

이식성

C언어의 표준화 덕분에, 소스 코드는 매우 적은 변경이나 추가 작업 없이도 다른 시스템으로 옮겨져 컴파일될 수 있다. 따라서, C언어로 작성된 프로그램은 다양한 플랫폼과 하드웨어에서 실행될 수 있다.

구조체를 통한 복잡한 데이터 구조의 구현

C언어는 구조체(struct)를 사용하여 사용자 정의 데이터 타입을 생성할 수 있다. 이를 통해 복잡한 데이터 구조를 효율적으로 표현할 수 있어 코드 가독성을 높일 수 있다.

코드 재사용

C언어는 함수를 통해 코드를 모듈 단위로 나눌 수 있다. 이를 통해 코드의 재사용성이 증가하고 유지 보수가 용이해진다. 또한, 헤더 파일을 통해 함수 선언과 정의를 분리할 수 있어, 대규모 프로젝트의 관리가 더욱 효율적으로 이루어질 수 있다.

그래서 C언어의 특징을 이렇게 요약하고자 한다.

저수준 언어와 고수준 언어의 특징을 모두 가진 언어

C언어 처리 과정

출처: https://gracefulprograming.tistory.com/16

전처리 과정

전처리 과정은 크게 두 부분으로 나눌 수 있다.

헤더 파일 삽입
매크로 치환 및 적용

#define 된 부분은 심볼 테이블에 저장되고, 심볼 테이블에 들어 있는 문자열과 같은 문자열을 만나면 #define 된 내용으로 치환한다. 이때 #ifdef와 같은 다른 전처리기 매크로들도 같이 처리된다.

컴파일 과정

컴파일 과정은 크게 전단부, 중단부, 후단부로 나눌 수 있다. 컴파일 결과로 .s 어셈블리 코드로 이루어진 파일이 만들어진다.

✔ 전단부

전단부에서는 소스코드가 올바르게 작성되었는지 분석하고, 중단부에 넘겨주기 위한 GIMPLE 트리를 생성하는 일을 수행한다.

GIMPLE 트리 : 소스 코드를 트리 형태로 표현한 자료 구조

과정

1. 어휘 분석: C 소스코드를 의미 있는 최소단위(토큰)로 나눈다.
2. 구문 분석: 토큰으로 Parse Tree를 만들면서 문법적 오류 검출
3. 의미 분석: Parse Tree를 이용해 문법적 오류는 없지만 의미상 오류가 있는지 검사
(함수 매개변수 잘못 사용, 변수 자료형 불일치 등)
4. 중간 표현 생성: 언어 독립적인 특성을 제공하기 위해 트리 형태의 중간 표현(GIMPLE Tree)을 생성

✔ 중단부

전단부에서 넘겨받은 GIMPLE 트리를 SSA(Static Single Assignment) 형태로 변환한 후 아키텍쳐 비종속적인 최적화를 수행한다.

SSA(Static Single Assignment)

각 변수가 정확히 한 번만 할당되는 중간 표현(IR) 유형을 말한다. 많은 상용 컴파일러를 포함하여 명령형 언어에 대한 대부분의 고품질 최적화 컴파일러에서 사용된다.

SSA 변환

변수마다 버전 부여

Φ 함수를 통해 재할당

Reference:
https://en.wikipedia.org/wiki/Static_single-assignment_form

아키텍처 비종속적인 최적화란 서로 다른 CPU 아키텍처에 구애받지 않고 공통적으로 수행할 수 있는 최적화를 말한다. 중단부에서는 SSA 기반으로 최적화를 수행한다.

✔ 후단부

후반부에서는 RTL Optimizer에 의해 아키텍처 비종속적인 최적화와 함께 아키텍처 종속적인 최적화를 수행한다.

아키텍처 종속적인 최적화는 각 프로그램 내의 명령어 중 아키텍처별로 좀 더 효율적인 명령어로 대체해 성능을 높이는 작업과 같이 아키텍쳐 특성에 따라 최적화를 수행하는 것을 말한다.

어셈블 과정

컴파일이 끝난 어셈블리 코드는 어셈블러에 의해 기계어로 어셈블 된다.

어셈블러에 의해 생성되는 목적코드(.o) 파일은 어셈블 된 프로그램의 명령어와 데이터가 들어있는 ELF 바이너리 포맷(Binary Format) 구조를 갖는다.

다음 단계인 링킹에서 링커가 바이너리 파일을 하나의 실행 파일로 묶기 위해서 각 바이너리의 정보를 효과적으로 파악하기 위해서(명령어와 데이터의 범위 등) 일정한 규칙을 갖게 형식화해놓은 것이다.

링킹 과정

링커는 오브젝트 파일들과 프로그램에서 사용된 표준 C 라이브러리, 사용자 라이브러리를 링크(Link)한다.

이렇게 링킹 과정이 끝나면 실행 가능한 실행 파일이 만들어지게 된다.

C언어를 사용하는 목적

✍ Instuction code를 생성할 수 있는 언어

CPU는 아래와 같은 자신이 이해할 수 있는 포맷이 있는데 이를 Instruction Format이라 한다.

메모리를 직접 제어할 수 있으며, 컴파일 결과 CPU가 직접 이해할 수 있는 Instruction code를 생성할 수 있다.

C언어는 포인터를 통해 메모리를 직접 제어할 수 있다는 점, 컴파일 결과 중간 코드 없이 바로 바이너리 코드를 생성할 수 있다는 점에서 시스템 제어와 효율성이 중요한 분야에서 유리하다.

void swap(int *xp, int *yp)
{
    int t0 = *xp;
    int t1 = *yp;
    *xp = t1;
    *yp = t0;
}

어셈블러 결과

✍ 포인터

데이터가 저장된 메모리의 주소값을 저장하는 변수
즉, 프로그래머가 컴퓨터 메모리에 직접 접근해서 제어할 수 있게 하는 도구

포인터는 접근한 값을 수정할 수 있다.

#include <stdio.h>

int main(void)
{
    int val1 = 10;
    int val2 = 20;
    int val3 = 30;

    printf("메모리상 val1 위치 : %d\n", &val1);
    printf("메모리상 val2 위치 : %d\n", &val2);
    printf("메모리상 val3 위치 : %d\n", &val3);

    int *cursor = &val1;

    //포인터 변수 cursor를 통해 val1 접근
    printf("val1의 주소: %d, 값: %d\n", &val1, val1);
    printf("cursor의 주소: %d, 값: %d\n", cursor, *cursor);

    *cursor = *cursor + 5;

    //포인터 변수는 가리키는 값을 공유한다.
    printf("val1의 주소: %d, 값: %d\n", &val1, val1);
    printf("cursor의 주소: %d, 값: %d\n", cursor, *cursor);

    return 0;
}

포인터는 접근한 값을 저장할 수 있다.

#include <stdio.h>
#define SIZE 1000

void swap(int *a, int *b);
void quickSort(int start, int end);

int a[SIZE];

int main(void)
{
    int size;
    printf("Array size : ");
    scanf("%d", &size);
    
    //배열 값 입력
    printf("Input array values >> ");
    for (int i = 0; i < size; i++) {
        scanf("%d", &a[i]);
    }
    
    quickSort(0, size - 1);

    printf("Result: ");
    for (int i = 0; i < size; i++)
    {
        printf("%d ", a[i]);
    }
    
    return 0;
}

void quickSort(int start, int end) {
    if (start >= end) return;

    int key = start, i = start + 1, j = end; //가장 좌측 값을 키로
    
    while (i <= j) {
        while (i <= end && a[i] <= a[key]) i++;
        while (j > start && a[j] >= a[key]) j--;
        
        if (i > j) swap(&a[key], &a[j]);
        else swap(&a[i], &a[j]);
    }
    
    quickSort(start, j - 1);
    quickSort(j + 1, end);
 }

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

포인터는 자료구조의 가장 앞 부분을 가리킨다.

#include <stdio.h>

struct Student
{
    int id;     // 학번
    int grade;  // 학년
    int total;  // 총학점
    char *name; // 이름
};

int main(void)
{
    struct Student student[3] = {{1, 3, 88, "Mike"}, {2, 4, 116, "Tony"}, {3, 1, 38, "Justin"}};
    struct Student *ptr;
    ptr = &student;

    printf(" **** Student Info ****\n");
    for (int i = 0; i < 3; i++)
    {
        printf("\nID: %d\n", ptr->id);
        printf("Grade: %d\n", ptr->grade);
        printf("Total score: %d\n", ptr->total);
        printf("Name: %s\n", ptr->name);
        printf("------------------------------");
        ptr++; // 구조체 시작 부분을 가리킴
    }

    return 0;
}

결과

도식화

References:

https://it-stargazer.com/c%EC%96%B8%EC%96%B4-%EC%9E%84%EB%B2%A0%EB%94%94%EB%93%9C-%EC%8B%9C%EC%8A%A4%ED%85%9C%EC%97%90%EC%84%9C-%EC%82%AC%EC%9A%A9%EC%9D%98-%EC%9D%B4%EC%9C%A0-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8/

https://lacommune.tistory.com/76

https://www.learncomputerscienceonline.com/instruction-cycle/

https://suhwanc.tistory.com/m/134

https://gracefulprograming.tistory.com/16

SSR에 JWT 적용이 부적합한 이유

dev-rootable — Sat, 8 Jun 2024 17:57:52 +0900

세션 방식으로 구현했던 SSR 서버에 JWT를 적용하면서 느낀 점을 정리하고자 한다.

문제점

Stateless 하지 않다.

SSR 서버는 매 요청마다 비즈니스 로직을 수행하고 컨트롤러를 통해 렌더링 한다. 이것은 매 요청마다 인증 토큰을 생성한다고 해석할 수 있다. Stateless 특징을 가지는 JWT를 사용할 때 서버의 발급은 1회고, 그 이후에는 검증만 수행한다. 결과적으로 Stateless 하지 않다고 볼 수 있다.

JWT 방식은 클라이언트 스토리지에 저장되기 때문에 쿠키를 통해 구현할 수 있다. 아래 코드는 세션 방식과 쿠키를 통해 JWT를 구현한 코드이다.

    @PostMapping("/login")
    public String login(@Valid @ModelAttribute("loginForm") LoginDto dto, BindingResult bindingResult,
                        @RequestParam(defaultValue = "/") String redirectURL) {

        log.info("로그인 검증");

        if (bindingResult.hasErrors()) {
            log.info("검증 에러 errors={}", bindingResult);
            return "login/signIn";
        }

        //로그인 유효성 검사
        Member loginMember = loginService.validationLogin(dto.getLoginId(), dto.getPassword());
        log.info("Login Member = {}", loginMember);

        if (loginMember == null) {
            bindingResult.reject("loginFail");
            return "login/signIn";
        }

        //로그인 성공 처리
        log.info("정상 입력으로 로그인 성공");

        httpSession.setAttribute("loginMember", new SessionMember(loginMember)); //세션에 회원 정보 저장


        return "redirect:" + redirectURL; //로그인 후 최초 위치로 돌아가도록

    }

위 코드는 세션 방식으로 로그인을 처리하는 코드다.

인증된 사용자라면 세션에 정보를 저장하고, 그렇지 않다면 검증 에러를 객체에 담아 적절한 뷰를 내려주는 식으로 동작한다.

@Slf4j
@Controller
@RequiredArgsConstructor
public class LoginController {
    
    private final TokenProvider tokenProvider;

    ...

    @PostMapping("/login")
    public String login(@Valid @ModelAttribute("loginForm") LoginDto dto, BindingResult bindingResult,
                        @RequestParam(defaultValue = "/") String redirectURL, HttpServletResponse res) {

        log.info("로그인 검증");

        if (bindingResult.hasErrors()) {
            log.info("검증 에러 errors={}", bindingResult);
            return "login/signIn";
        }

        //로그인 유효성 검사
        Member loginMember = loginService.validationLogin(dto.getLoginId(), dto.getPassword());
        log.info("Login Member = {}", loginMember);

        if (loginMember == null) {
            bindingResult.reject("loginFail");
            return "login/signIn";
        }

        //로그인 성공 처리
        log.info("정상 입력으로 로그인 성공");

        Map<String, Object> member = new HashMap<>();
        member.put("loginId", dto.loginId);
        member.put("password", dto.password);

        //10분 후 만료되는 jwt 생성하여 쿠키에 저장
        Cookie cookie = new Cookie(JwtLoginInterceptor.COOKIE_NAME, 
                             tokenProvider.createToken(member, Optional.of(LocalDateTime.now().plusMinutes(10)))
                        );

        cookie.setPath("/");
        cookie.setMaxAge(Integer.MAX_VALUE);
        
        res.addCookie(cookie);

        return "redirect:" + redirectURL; //로그인 후 최초 위치로 돌아가도록

    }
    
}

위 코드를 서비스에서 처리하거나 Spring Security 설정 클래스에서 해당 로직을 처리하는 커스텀 Filter를 등록하여 처리할 수도 있다. 어떤 방식을 사용하든 Client의 요청마다 해당 로직이 동작한다. 이것은 추가적인 연산 오버헤드를 발생시켜 성능 저하를 초래할 수 있다.

JWT의 보안 취약점

JWT 방식은 다음과 같은 이유로 보안 취약점이 뚜렷하다.

저장소가 Client 측에 있어 XSS(Cross Site Scripting) 공격에 취약하다.
Payload가 Base64로 인코딩되었을 뿐, 암호화된 것이 아니다.
암호화 알고리즘에 취약점이 있을 수 있다.
발급한 JWT는 서버에서 통제할 방법이 없다.

SSR 특성과의 부적합

JWT는 Client 측에서 관리하기 때문에 Javascript로 처리해야 한다. SSR 환경에서는 Javascript를 JQuery를 통해 HTML에 삽입하거나 Ajax를 통해 비동기 통신으로 처리해야 하므로 Javascript를 사용하기 불편하다는 단점이 있다.

References:

https://zks145.tistory.com/106

[Spring] SSR에서 JWT를 이용한 인증/인가 처리 고민

SSR과 JWT에 대한 고찰여기저기 글을 찾아보면 LocalStorage, Cookie를 이용해 JWT 관리하게 되는데 Spring Boot에서 JSP, thymeleaf 같이 SSR 기반 방식의 경우 JWT를 사용하는 경우는 거의 없습니다. SSR 경우 대

zks145.tistory.com

https://okky.kr/questions/1488896

OKKY - Spring boot SSR에서는 JWT를 지양하는 이유?

SSR 기반으로 클라이언트를 구성하던 도중에 JWT이용해 인증/인가 처리를 하려고 했습니다. 그런데 해당 방식으로 구현한 소스를 찾아보는데 SSR에서는 JWT를 이용하는 방식보다는 세션을 이용해

okky.kr

https://stove99.github.io/java/2019/08/02/springboot-with-jwt/

JAVA : SpringBoot2 & Thymeleaf 에서 JWT 이용해서 로그인 하기

SpringBoot2 & Thymeleaf 로 구성된 전통적인(?) 환경에서 JWT 를 이용한 로그인 처리 샘플

stove99.github.io

허프만(Huffman) 알고리즘

dev-rootable — Wed, 29 May 2024 13:37:18 +0900

허프만 알고리즘이란?

압축 단위마다 문자의 출현 빈도를 조사하여 빈도가 높은 순서대로 비트 수가 적은 부호를 부여함으로써 데이터를 압축하는 방식

즉, 많이 사용된 문자는 더 적은 비트로 나타내고, 적게 사용된 문자는 더 많은 비트를 사용하여 효율적으로 문자열을 나타내는 방식을 말한다.

문자 압축 예제

AAAAAABBBBCDD => 'A' 6개, 'B' 4개, 'C' 1개, 'D' 2개

‍♂️ 항 합치기

가장 적은 사용 빈도를 가진 두 항을 묶고 그 합을 적어준다.

이와 같이 한번 더 묶는다.

마지막 남은 A까지 묶어주면 다음과 같은 그림이 나온다.

‍♂️ 비트 부여하기

루트 노드를 기준으로 왼쪽으로 한번 가면 0, 오른쪽으로 가면 1이라고 하겠다.

A ➡ 0
B ➡ 10
C ➡ 110
D ➡ 111

이를 사용하여 AAAAAABBBBCDD는 00000010101010110111111이 된다.

이처럼 문자의 사용 빈도를 이용하여 문자열을 압축하는 알고리즘이 허프만 알고리즘이다.

특징

✅ 모호성 제거

만약 다음과 같은 가변 길이 코드 변환 규칙이 있다고 하자.

{A, B, C, D} => {0, 01, 10, 1}

이때, AB와 AAD는 '001'로 동일하게 표현되기 때문에 모호성이 발생한다. 이를 해결하기 위해서는 어떠한 문자도 다른 문자의 prefix를 가지지 않으면 된다.

위에서 살펴봤던 허프만 코드는 이렇다.

{A, B, C, D} => {0, 10, 110, 111}

위와 같이 표기할 경우 어떠한 문자도 다른 문자의 prefix가 되는 경우가 없다. 따라서 허프만 코드는 모호성이 없다.

✅ 공간 절약

아래와 같은 빈도의 문자열이 있다고 하자.

문자	빈도	fixed-length	variable-length
A	60%	00	0
B	25%	01	10
C	10%	10	110
D	5%	11	111

fixed-length 코드를 사용하면 2비트만을 필요로 하기 때문에 공간적인 측면에서 절약이 가능하지만 모호성이 발생할 수 있다. 반면, variable-length 코드를 사용하면 1 ~ 3비트를 사용하므로 공간적인 절약을 항상 보장할 수 없지만 prefix-free 코드이므로 모호성이 발생하지 않는다.

하지만 variable-length 코드는 문자 출현 빈도에 따라 나타내는 비트 수가 다르기 때문에 평균적으로 1.55의 공간을 필요로 한다. 따라서 평균적으로는 fixed-length 코드의 평균 2보다 더 나은 효율성을 보인다.

구현

허프만 알고리즘은 Heap을 통해 구현된다. 그래서 힙으로 구현된 우선순위 큐를 이용하여 구현할 수 있다.

먼저 문자의 빈도 수에 따른 이진 트리를 생성하기 위해 아래와 같이 Node 클래스를 작성한다.

class Node {
    char word;
    int freq;
    Node left = null, right = null;
    
    Node(char word, int freq) {
        this.word = word;
        this.freq = freq;
    }
    
    Node(Node left, Node right) {
        this.freq = left.freq + right.freq; //항 합치기
        this.left = left;
        this.right = right;
    }
}

각 단어의 빈도를 집계하는 Map을 생성한다.

각 Node의 빈도 수가 적은 것부터 추출하기 위해 우선순위 큐를 이용하여 이진 트리를 생성한다.

poll()을 수행할 때마다 빈도 수가 적은 것부터 추출되고, 이를 다시 합쳐서 큐에 넣는 작업을 반복한다.

압축 결과를 출력하기 위해 optBits에 집계한 최적 비트를 통해 원본(txt)를 수정한다.

public void HuffmanCoding(String txt) {
    Map<Character, Integer> stat = new HashMap<>();
    for (char c : txt.toCharArray()) {
        stat.put(c, stat.getOrDefault(c, 0) + 1); //누적
    }
    
    //우선순위 큐를 통해 정렬
    PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingInt(node -> node.freq));
    for (Map.Entry<Character, Integer> entry : stat.entrySet()) {
        pq.add(new Node(entry.getKey(), entry.getValue()));
    }
    
    //허프만 알고리즘에 따른 이진 트리 생성
    while (pq.size() > 1) {
        Node left = pq.poll();
        Node right = pq.poll();
        pq.add(new Node(left, right));
    }
    
    printCompression(pq.peek(), "");
    
    for (Map.Entry<String, String> entry : optBits.entrySet()) {
        txt = txt.replaceAll(entry.getKey(), entry.getValue());
    }

    System.out.println("압축 결과: " + txt);
}

이진 트리에서 왼쪽으로 이동할 때마다 '0'을 부여하고, 오른쪽으로 이동할 때마다 '1'을 부여했다.

노드의 좌우가 null이라는 것은 리프 노드에 도달했음을 의미하므로 출력을 수행한다. 이때, optBits 맵에 각 단어에 대한 variable-length 코드를 저장한다.

private static void printCompression(Node node, String comp) {
    if (node == null) return;
    
    //리프 노드에 도달한 경우 출력
    if (node.left = null && node.right == null) {
        optBits.put(node.word + "", comp); //압축 결과를 출력하기 위해 Map에 저장
        System.out.println(node.word + "-> " + comp);
    }
    
    //비트 압축
    printCompression(node.left, comp + "0");
    printCompression(node.right, comp + "1");
}

public class Huffman {

    static Map<String, String> optBits = new HashMap<>();

    ...

    public static void main(String[] args) {
        Huffman o = new Huffman();
        o.HuffmanCoding("AAAAAABBBBCDD");
    }
    
}

"AAAAAABBBBCDD"에 대해 부여된 최적 이진 코드

이 결과는 아래와 같은 이진 트리가 만들어진 케이스다.

그래서 최적 이진 코드는 하나의 케이스만 나오지 않는다.

이처럼 허프만 알고리즘은 그리디 알고리즘으로 그리디 선택 속성과 최적 부분 구조 조건을 만족하는 경우 최적화 문제를 효율적으로 해결할 수 있다.

References:

https://dy-coding.tistory.com/entry/%EB%B0%B1%EC%A4%80-13975%EB%B2%88-%ED%8C%8C%EC%9D%BC-%ED%95%A9%EC%B9%98%EA%B8%B0-3-java

백준 13975번 : 파일 합치기 3 java

이 문제는 허프만 알고리즘을 이용하여 푸는 문제입니다. 허프만 알고리즘에 대하여 우선 설명드리도록 하겠습니다. 허프만 알고리즘이란 압축 단위마다 문자의 출현 빈도를 조사하여 빈도가

dy-coding.tistory.com

https://yozm.wishket.com/magazine/detail/2478/

탐욕 알고리즘과 허프만 코딩 구현 방법 | 요즘IT

탐욕 알고리즘(Greedy Algorithm)은 각 단계에서 최적의 해결책을 선택하여 복잡한 문제를 간단하고 빠르게 해결하는 알고리즘을 말합니다. 이번 글에서는 탐욕 알고리즘의 기본 개념과 작동 원리를

yozm.wishket.com

https://mirrorofcode.tistory.com/entry/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-Huffman-code-%ED%97%88%ED%94%84%EB%A7%8C%EC%BD%94%EB%93%9C

[알고리즘] Huffman code / 허프만코드

Huffman code 란?압축은 자료의 크기를 줄이기 위해서 사용된다. 그리고 이 압축을 하는 방식에 따라서 압축된 파일의 용량이 달라질 수 있는데, 그 중 Huffman code는 문자의 출현 빈도에 따라서 다

mirrorofcode.tistory.com

람다식과 함수형 인터페이스

dev-rootable — Wed, 22 May 2024 14:25:45 +0900

❓ 람다식이란?

메서드를 하나의 식(expression)으로 표현한 것

메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명 함수(anonymous function)'라고도 한다.

int method() {
    return (int) (Math.random() * 5) + 1);
}

위의 메서드를 람다식으로 바꾸면 다음과 같다.

int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int) (Math.random() * 5) + 1);

람다식의 장점

✔ 간결한 코드

모든 메서드는 클래스에 포함되어야 하므로 클래스를 새로 만들어야 하고, 객체도 생성해야만 비로소 메서드를 호출할 수 있다. 그러나 람다식은 이러한 과정 없이 오직 람다식 자체만으로도 메서드의 역할을 대신할 수 있다.

✔ 메서드를 변수처럼 다룰 수 있음

람다식은 메서드의 매개변수로 전달이 가능하고, 람다식 자체를 메서드의 결괏값으로 반환할 수도 있다. 이처럼 람다식으로 인해 메서드를 변수처럼 다루는 것이 가능해진 것이다.

✔ 함수형 인터페이스 활용

함수형 인터페이스와 결합하여 코드의 간결성과 가독성을 향상할 수 있다. 자바에서는 기본적으로 사용할 수 있는 다양한 함수형 인터페이스를 제공한다. 대표적으로 Runnable, Callable, Comparator, Predicate, Function, Consumer, Supplier 등이 있다. 이러한 함수형 인터페이스를 통해 대부분의 코드를 처리할 수 있다.

✔ 익명 클래스 사용 대체

자바 람다식과 함수형 인터페이스를 사용하면 익명 클래스의 선언을 대체할 수 있다. 이를 통해 코드를 더욱 간결하게 만들고, 익명 클래스의 중복 사용에 따른 코드의 중복을 줄일 수 있다. 예를 들어 여러 번 정렬이 필요한 상황에서 Comparator를 사용한다면 코드 중복이 발생하고 코드 가독성이 떨어지게 되는데, 이러한 상황에서 람다식을 사용하여 해결할 수 있다.

✔ 스트림 API 활용

Java 8부터 도입된 스트림 API는 컬렉션에 저장된 데이터를 간결하게 처리할 수 있는 기능을 제공한다. 특히 람다식과 스트림 API를 결합하여 데이터 필터링, 매핑, 집계 등의 작업을 직관적으로 수행할 수 있다. 이러한 스트림 API를 활용하여 함수형 프로그래밍 스타일로 더욱 직관적이고 간결한 코드를 작성할 수 있다.

람다식 작성하기

람다식은 메서드의 매개변수 타입을 생략할 수 있다.
- 단, 두 매개변수 중 어느 하나의 타입만 생략하는 것은 허용되지 않는다.
반환값이 있는 메서드의 경우, return문 대신 식(expression)으로 대신할 수 있다. 식의 연산 결과가 자동으로 반환값이 된다. (세미콜론 제외)
매개변수가 하나인 경우에는 괄호를 생략할 수 있다.
- 단, 매개변수의 타입이 있으면 괄호를 생략할 수 없다.
{} 안의 명령문이 하나일 때는 {}를 생략할 수 있고, 세미콜론을 붙이지 않는다.

int max(int a, int b) {
    return a > b ? a : b;
}

(a, b) -> a > b ? a : b

함수형 인터페이스(Functional Interface)와 람다식

람다식은 익명 클래스의 객체와 동등하다

(a, b) -> a > b ? a : b

new Object() {
    int max(int a, int b) {
        return a > b ? a : b;
    }
}

위는 람다식이고, 아래는 이것을 익명 클래스의 객체로 변환한 것이다.

위의 메서드를 호출하려면 익명 클래스의 객체를 받아야 하는데, 참조형이므로 클래스 또는 인터페이스로 받아야 한다.

타입 f = (a, b) -> a > b ? a : b;

람다식을 받을 수 있는 클래스 또는 인터페이스는 람다식과 동등한 메서드가 정의되어 있는 것이어야 한다.

아래와 같은 인터페이스가 있다고 가정하자.

interface MyFunction {
    public abstract int max(int a, int b);
}

해당 인터페이스를 구현한 익명 클래스의 객체를 다음과 같이 생성할 수 있다.

MyFunction f = new MyFunction() {
                   public int max(int a, int b) {
                       return a > b ? a : b;
                   }
               };
               
int maxVal = f.max(5, 3); //익명 객체의 메서드 호출

MyFunction 인터페이스에 정의된 메서드 max()가 람다식과 일치하기 때문에 아래와 같이 대체할 수 있다.

MyFunction f = (a, b) -> a > b ? a : b; //익명 객체를 람다식으로 대체
int maxVal = f.max(5, 3); //익명 객체의 메서드 호출

위처럼 익명 객체를 람다식으로 교체 가능한 이유는 람다식도 실제로는 익명 객체이기 때문이다. 이렇게 대체하기 위해서는 람다식의 매개변수 타입 및 개수와 반환값이 일치해야 한다.

결론

지금까지 살펴본 것처럼, 하나의 메서드가 선언된 인터페이스를 정의해서 람다식을 다루는 것은 기존의 자바 규칙들을 어기지 않으면서도 자연스럽다.

그래서 인터페이스를 통해 람다식을 다루기로 결정되었으며, 람다식을 다루기 위한 인터페이스를 '함수형 인터페이스(functional interface)'라고 부르기로 했다.
@FunctionalInterface //컴파일러가 함수형 인터페이스를 올바르게 정의했는지 확인함
interface MyFunction { //함수형 인터페이스
    public abstract int max(int a, int b);
}
단, 함수형 인터페이스는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다. 그래야 람다식과 인터페이스의 메서드가 일대일로 연결되기 때문이다. static, default 메서드의 개수는 제약이 없다.

함수형 인터페이스 타입과 매개변수의 반환타입

메서드의 매개변수가 MyFunction(함수형 인터페이스) 타입이면, MyFunction의 메서드를 호출할 때 람다식을 참조하는 참조변수를 매개변수로 지정해야 한다. 마찬가지로 람다식은 함수형 인터페이스의 추상 메서드와 동등해야 한다.

@FunctionalInterface
interface MyFunction {
    void myMethod();
}

void aMethod (MyFunction f) { //매개변수 타입이 함수형 인터페이스
    f.myMethod(); //함수형 인터페이스의 추상 메서드 호출
}

MyFunction f = () -> System.out.println("myMethod()"); //람다식을 참조하는 참조변수
aMethod(f);

참조변수 없이 아래와 같이 직접 람다식을 매개변수로 지정할 수 있다.

aMethod(() -> System.out.println("myMethod()");

메서드의 반환타입이 함수형 인터페이스라면, 해당 함수형 인터페이스의 추상 메서드와 동등한 람다식을 가리키는 참조변수를 반환하거나 람다식을 직접 반환할 수 있다.

MyFunction myMethod() {
    MyFunction f = () -> {};
    return f; //return () -> {}; 으로 줄일 수 있음
}

람다식의 타입과 형변환

람다식은 오직 함수형 인터페이스로만 형변환이 가능

@FunctionalInterface
interface MyFunction {
    void method();
}

함수형 인터페이스의 메서드와 동등한 람다식(매개변수 & 반환값 일치)을 함수형 인터페이스로 형변환할 수 있다.

MyFunction f = (MyFunction) (() -> System.out.println("Lambda"));
MyFunction f = (Object) (() -> System.out.println("Lambda")); //불가능
Object o = (Object) (MyFunction) (() -> System.out.println("Lambda")); //가능

람다식은 익명 객체지만 타입이 존재한다. 하지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없는 것이다.

람다식의 타입: 외부클래스이름$$Lambda$번호

일반적인 익명 객체는 객체의 타입이 '외부클래스이름$번호'와 같은 형식으로 타입이 결정되지만 람다식의 타입은 '외부클래스이름$$Lambda$번호'와 같은 형식으로 된다.

람다식에서 외부 변수 참조

✔ 지역 변수

람다식에서 참조하는 지역 변수는 final이 붙지 않았어도 상수로 간주한다. 따라서, 람다식 내에서 참조하는 지역 변수는 람다식 내에서나 다른 어느 곳에서나 값을 변경할 수 없다.

✔ 람다식 밖의 인스턴스 변수

람다식 밖 클래스의 인스턴스 변수는 람다식 내에서 참조하더라도 상수로 간주되지 않으므로 값을 변경할 수 있다.

@FunctionalInterface
interface MyFunction2 {
    void myMethod();
}

class Outer{
    int val = 10; //Outer.this.val
	
    class Inner{
        int val = 20; //this.val
		
        void method(int i) { //void method(final int i)
            int val = 30; //final int val = 30;
//          i = 10; error -> final val can't change
			
            MyFunction2 f = () -> {
                System.out.println("             i : " + i);
                System.out.println("           val : " + val);
                System.out.println("      this.val : " + this.val);
                System.out.println("Outer.this.val : " + Outer.this.val);
            };
			
            f.myMethod();
        }
    }
}

public class LambdaEx3 {
	public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.method(100);
    }
}

Test 결과

외부 지역 변수와 동일 이름의 람다식 매개변수는 허용되지 않는다.

@FunctionalInterface
interface MyFunction2 {
    void myMethod();
}

class Outer{
    int val = 10; //Outer.this.val
	
    class Inner{
        int val = 20; //this.val
		
        void method(int i) { //void method(final int i)
            int val = 30; //final int val = 30;
//          i = 10; error -> final val can't change
			
            MyFunction2 f = (i) -> { //error -> i는 변수 이름 중복
                System.out.println("             i : " + i);
                System.out.println("           val : " + val);
                System.out.println("      this.val : " + this.val);
                System.out.println("Outer.this.val : " + Outer.this.val);
            };
			
            f.myMethod();
        }
    }
}

❓ 익명 객체(익명 클래스)란?

프로그램에서 일시적으로 한 번만 사용되고 버려지는 객체

익명 객체(익명 클래스)를 사용하는 이유

익명 객체는 나중에 재사용이 되지 않는다. 이 말은 확장성이 그렇게 좋지 못하다는 것을 의미한다. 자바에서 확장성을 고려한 설계는 매우 중요하지만 이로 인해 유지보수에서 더 불리한 경우도 있다. 그래서 다음과 같은 경우에 사용하는 것이 좋다.

프로그램 내에서 일회용으로 사용되어야 하는 객체 (ex. UI 이벤트 처리, 스레드 객체 등 단발성 이벤트 처리)
재사용성이 없고, 확장성을 활용하는 것이 유지보수에서 더 불리할 때
- 비즈니스 로직이 재각각이며, 재사용성이 전혀 없어 매번 클래스를 생성해야 하는 비용이 큰 상황

References:

https://limkydev.tistory.com/226

[Java] 익명객체(익명클래스)란? (이 글 하나로 한방에 정리!)

익명객체(익명클래스) 란? 이번시간에는 자바 익명객체(익명클래스)에 대해서 알아보도록 하겠습니다. 익명객체(익명클래스) 말그대로.. 이름이 없는 객체? 클래스?,,,그래서 무명클래스라고도

limkydev.tistory.com

https://yozm.wishket.com/magazine/detail/2023/

코드 가독성 높이는 자바 람다식과 함수형 인터페이스 | 요즘IT

자바(Java)는 시간이 지남에 따라 발전하면서 더욱 효율적이고 간결한 코드를 작성할 수 있도록 다양한 기능을 제공하고 있습니다. 특히 자바 8부터 도입된 람다식과 함수형 인터페이스는 자바에

yozm.wishket.com

Java의 static 키워드

dev-rootable — Fri, 17 May 2024 12:49:45 +0900

❓ static 이란?

모든 인스턴스에서 공유되는 static 변수

자바에서 static 키워드는 클래스 레벨의 변수나 메서드, 블록을 정의할 때 사용된다. 이는 인스턴스 생성 없이도 접근 가능하며, 모든 인스턴스에서 공유된다. static 변수는 클래스가 로드될 때 Method 영역에 할당되기 때문에 프로그램 시작부터 종료까지 메모리에 유지된다. 이러한 특성으로 인해 모든 인스턴스가 공유하여 사용할 수 있는 변수가 필요할 때 유용하다.

static 변수

static 변수는 클래스 레벨에서 선언되며, 모든 인스턴스에 의해 공유된다. 그래서 특정 데이터를 모든 인스턴스가 공유해야 할 때 유용하다.

다음은 static 변수 사용 예시다.

public class Calculator {

    public static int value; //default 0
    
    public void add() {
        value++;
    }
    
    public void subtract() {
        value--;
    }
    
}

static 메서드

정적인 값(상태를 가지지 않는 값)에 대한 연산에 유용

static 메서드는 인스턴스 생성 없이 클래스 이름을 통해 직접 호출할 수 있다. 주로 유틸리티 함수나 인스턴스의 상태에 의존하지 않는 연산을 수행할 때 유용하다. 왜냐하면 static 메서드는 클래스의 다른 static 메서드나 변수만 접근할 수 있고, 인스턴스 멤버에 접근할 수 없기 때문이다. 즉, 정적인 값만 다룬다는 것이다.

잠시 Java의 인스턴스 멤버를 살펴보자.

인스턴스 멤버는 new 연산자를 통해 객체를 생성한 후 사용할 수 있는 값으로 객체 없이는 사용할 수 없다. 인스턴스 필드는 Heap 영역에 객체마다 따로 존재하고, 인스턴스 메서드는 Method 영역에 저장되어 같은 클래스의 인스턴스끼리 공유한다. 여기서 알 수 있는 점은 인스턴스 멤버는 객체 단위로 메모리를 할당받고, 그 객체의 변수나 메서드를 공유한다.

객체에 묶여 있는 인스턴스 멤버는 상태가 있는 데이터를 다루고, 클래스에 묶여 있는 static 메서드는 상태가 없는 데이터를 다룬다.

public class MyCalculator {

    public static int add(int x, int y) {
        return x + y;
    }
    
    public int subtract(int x, int y) {
        return x - y;
    }
    
}

    MyCalculator.add(3, 4); //static method => 클래스명으로 사용 o
    MyCalculator.subtract(5, 3); //not static method => 객체 생성 후 사용해야 함

static 블록

static 블록은 클래스가 처음 로드될 때 한 번만 실행되는 코드 블록이다. 그래서 프로그램 시작 시 필요한 리소스를 준비하는 초기화 작업에 적합하다. 주로 static 변수의 초기화에 사용된다.

static class Machine {

    static String type = "Init";
    
    static {
        System.out.println("Operating Test");
        type = "Testing";
    }
    
}

static 키워드의 남용 주의

메모리 낭비

자바에서 static 키워드는 동일한 값을 유지하기 때문에 인스턴스처럼 복사본을 유지할 필요가 없으므로 메모리 사용을 최적화할 수 있고 속도가 빠르다. 하지만 static 변수가 남용되면 오히려 프로그램 퍼포먼스에 부정적인 영향을 줄 수 있다.

static 변수가 저장되는 곳은 Method 영역이다. 해당 영역은 명시적 NULL을 선언하지 않는 한 프로그램 종료까지 메모리에 생존한다. 그래서 프로그램 생명주기 동안 메모리에 상주하므로, 불필요한 static 사용은 프로그램 성능 저하로 이어질 수 있다.

객체지향 원칙 위반

static은 객체지향적이지 못하다.

객체지향 프로그래밍 원칙에 따르면, 한 객체가 지니고 있는 데이터들은 외부에서 함부로 접근하여 수정할 수 없도록 해야 한다. 하지만 static은 따로 객체를 생성하지 않고 클래스를 통해 직접 데이터를 불러오기 때문에 각 객체의 데이터들이 캡슐화되어야 한다는 객체지향 프로그래밍의 원칙을 위반한다.

재사용성

static 메서드는 Interface를 구현하는 데 사용될 수 없다. 따라서, 재사용성을 높여주는 객체지향적 설계에 방해될 수 있다.

References:

https://f-lab.kr/insight/understanding-and-using-java-static-keyword?gad_source=1&gclid=Cj0KCQjw3ZayBhDRARIsAPWzx8olhQnAc3pmvw4u5YKdOQbAZLied7ddvvXDfql8eWX-SwyPozlANxcaAuTtEALw_wcB

자바에서의 static 키워드 이해와 올바른 사용법

자바에서 static 키워드의 기본적인 사용법과 주의점, 그리고 효과적인 사용 사례에 대해 알아보는 글입니다.

f-lab.kr

https://velog.io/@gudonghee2000/static-vs-%EC%8B%B1%EA%B8%80%ED%86%A4-%ED%8C%A8%ED%84%B4

Static사용의 장점과 단점

* Static * Static : 자바 언어 예약어로 클래스 메서드와 클래스 필드를 지정할 때 사용한다. 인스턴스를 생성하지 않아도 클래스의 메서드와 필드에 접근을 가능하게 한다. * Static 함수, 변수의 메

velog.io

https://bambookim.tistory.com/17

[Java] 인스턴스 멤버 vs. 정적 멤버와 static

인스턴스 멤버 인스턴스 멤버는 객체(인스턴스)를 생성한 뒤 사용할 수 있는 필드와 메소드이다. 인스턴스 필드와 메소드는 객체에 소속된 멤버이기 때문에 객체 없이는 사용할 수 없다. public cl

bambookim.tistory.com

https://velog.io/@yyy96/static

static 과 객체지향적 관점

static 에 관하여. 그리고 자바가 static을 지양하는 이유는?

velog.io