업글인간의 정보 리뷰

TCP/IP 패킷 수신(패킷 분리 및 합침)

업글 — Wed, 15 Dec 2021 00:37:21 +0900

안녕하세요 업글입니다!

기본적인 TCP/IP 통신에 대한 예제들은 구글링을 통해서 쉽게 찾을 수 있습니다. 그러나 기본적인 함수 사용에 대한 내용이므로 바로 프로젝트 또는 현업에 적용하는 것은 쉽지 않습니다.

해당 포스팅에서는 TCP/IP 통신에서 패킷 수신 시 고려사항과 해당 사항을 고려한 로직 및 C/C++ 기반의 코드에 대해서 설명드리겠습니다.

TCP/IP 통신은 MSS 사이즈, 윈도우 사이즈, 네이글 알고리즘 등과 같은 특징들에 의해서 상대측 어플리케이션 레벨에서 송신한 패킷이 분리되거나 합쳐져서 송신되어 수신 시에 분리되거나 합쳐져서 수신되는 경우가 있습니다.

패킷 분리되는 경우

abcdef 송신

abc, def로 분리

위의 그림은 패킷 분리에 대한 예시로 상대측 어플리케이션 레벨에서 한번에 abcdef를 송신하였는데 수신 함수를 통해서 첫번째 수신하였을 때는 abc, 두번째 수신하였을 때는 def가 수신되는 경우입니다. TCP 관련 Layor를 통해서 abc, def로 분리된 후 송신되어 분리된 패킷을 수신하게 됩니다.

패킷 합쳐지는 경우

abc, def로 2번 송신

abcdef 수신

위의 그림은 패킷 분리와 반대의 경우로 합쳐지는 경우입니다. 상대측에서 첫번째로 abc를 송신하고 두번째로 def를 송신하였을 때 수신하는 경우에는 abcdef가 한번에 들어오는 경우입니다. 위에서 설명드린 것과 같이 TCP 관련 Layor를 통해서 abc, def 패킷이 합쳐진 후 송신되어 1개의 패킷을 수신하게 됩니다.

위의 예시와 같이 여러가지 경우로 패킷이 분리되거나 합쳐질 수 있습니다. TCP/IP 통신 시에 데이터의 형태나 크기가 다른 여러 메시지를 송수신 하기 때문에 이를 고려하여 패킷 수신 로직을 구현 해주셔야 합니다. 구현에 있어서 정답은 없고 사람 및 회사에 따라서 방식에 차이가 있을 것으로 보입니다.

데이터의 앞부분에 헤더를 붙여서 통신하는 방식을 설명드리겠습니다. 헤더는 메시지 ID, 송수신 장비 번호, 메시지 크기 등과 같은 내용을 포함하게 됩니다. 패킷의 유효성 검사를 위해서 START/END CODE 및 CHECK SUM/CRC와 같은 항목을 추가하셔도 됩니다.

코드로 자세히 설명드리겠습니다. 위에서 설명되는 경우에 대한 처리는 main.c 코드의 ThreadParsing 부분에서 진행함으로 이 부분을 집중적으로 보시는 것을 추천드립니다. TCP/IP 통신 및 데이터 큐 코드는 중요도가 낮으므로 해당 로직에 대한 설명과 테스트 결과에 대한 설명 뒷부분에 게시하였습니다.

Visual Studio 속성 > 전처리기에서 _WINSOCK_DEPRECATED_NO_WARNINGS를 추가하셔야 에러없이 동작됨을 참고하시기 바랍니다.

main.c 코드

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

#include "dataQueue.h"
#include "tcpIpComm.h"

#include <windows.h>

#pragma pack(push, 1)
typedef struct {
    uint32_t msgId;
    uint32_t srcId;
    uint32_t dstId;
    size_t msgSize;
}ST_MsgHeader;

typedef struct {
    ST_MsgHeader msgHeader;
    int8_t data[10];
}ST_TestPacket;
#pragma pack(pop) 

typedef enum {
    CONNECT,
    RECV,
    SEND
}CommStat;

typedef enum {
    WAIT_HEADER_RECV,
    GET_HEADER,
    WAIT_DATA_RECV,
    GET_DATA,
    MSG_SEND
}ParsingStat;

ST_Queue g_queue;

DWORD WINAPI ThreadReceive(void * arg)
{
    SOCKET clntSocket;

    CommStat stat = CONNECT;
    while (TRUE) {
        switch (stat) {
            case CONNECT:
                if (ClntConnection(5000, &clntSocket, SERV_IP_ADDR) == FALSE) {
                    Sleep(1000);
                }
                else {
                    stat = RECV;
                }
                break;
            case RECV:
                if (ClntRecv(&clntSocket, &g_queue) == FALSE) {
                    stat = CONNECT;
                }
                break;
        }

        Sleep(0);
    }    
}

DWORD WINAPI ThreadParsing(void* arg)
{
    int32_t i;
    int8_t * msg = NULL;
    ST_MsgHeader msgHeader;
    ParsingStat stat = WAIT_HEADER_RECV;

    while (TRUE) {
        switch (stat) {
        case WAIT_HEADER_RECV:
            if (QueueSize(&g_queue) >= sizeof(ST_MsgHeader)) {
                stat = GET_HEADER;
            }
            break;
        case GET_HEADER:
            QueueAddrPop(&g_queue, (int8_t*)&msgHeader, sizeof(ST_MsgHeader));
            stat = WAIT_DATA_RECV;
            break;
        case WAIT_DATA_RECV:
            if (QueueSize(&g_queue) >= (msgHeader.msgSize - sizeof(ST_MsgHeader))) {
                stat = GET_DATA;
            }
            break;
        case GET_DATA:
            msg = (int8_t *)malloc(msgHeader.msgSize);
            memcpy(msg, &msgHeader, sizeof(ST_MsgHeader));
            QueueAddrPop(&g_queue, &msg[sizeof(ST_MsgHeader)], (msgHeader.msgSize - sizeof(ST_MsgHeader)));
            stat = MSG_SEND;
            break;

        case MSG_SEND:
            printf("msgId=%d, srcId=%d, dstId=%d, msgSize=%d\n", msgHeader.msgId, msgHeader.srcId, msgHeader.dstId, msgHeader.msgSize);
            for (i = 0; i < (msgHeader.msgSize - sizeof(ST_MsgHeader)); i++) {
                printf("%d,", msg[sizeof(ST_MsgHeader) + i]);
            }
            printf("\n");
            switch (msgHeader.msgId) {
                // msgId 별 처리 ex) 다른 쓰레드로 전달
            }
            free(msg);
            stat = WAIT_HEADER_RECV;
            break;
        }

        Sleep(0);
    }
}

DWORD WINAPI ThreadSend(void* arg)
{
    int32_t i, j;
    SOCKET servSocket, clntSocket;
    ST_TestPacket packet[3];

    for (j = 0; j < 3; j++) {
    
        packet[j].msgHeader.msgId = j+1;
        packet[j].msgHeader.srcId = 1;
        packet[j].msgHeader.dstId = 2;
        packet[j].msgHeader.msgSize = sizeof(ST_TestPacket);

        for (i = 0; i < 10; i++) {
            packet[j].data[i] = j+1;
        }
    }

    CommStat stat = CONNECT;
    while (TRUE) {
        switch (stat) {
        case CONNECT:
            if (ServConnection(5000, &servSocket , &clntSocket) == FALSE) {
                Sleep(1000);
            }
            else {
                stat = SEND;
            }
            break;
        case SEND:
            // case 1 분할
            send(clntSocket, &packet[0], sizeof(ST_MsgHeader) + 5, 0);
            send(clntSocket, ((int8_t *)&packet[0] + sizeof(ST_MsgHeader) + 5), 5, 0);

            // case 2 합
            send(clntSocket, &packet[1], sizeof(ST_TestPacket) * 2, 0);
            Sleep(10000);
            break;
        }

        Sleep(0);
    }
}


int main()
{
    if (QueueInit(&g_queue, QUEUE_LENGTH) == NO) {
        printf("queue init fail\n");
    }

    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    HANDLE hReceiveThrd, hParsingThrd, hSendThrd;
    DWORD threadId, threadParam;
    hReceiveThrd = CreateThread(NULL, 0, ThreadReceive, &threadParam, 0, &threadId);
    hParsingThrd = CreateThread(NULL, 0, ThreadParsing, &threadParam, 0, &threadId);
    hSendThrd = CreateThread(NULL, 0, ThreadSend, &threadParam, 0, &threadId);

    WaitForSingleObject(hReceiveThrd, INFINITE);
    WaitForSingleObject(hParsingThrd, INFINITE);
    WaitForSingleObject(hSendThrd, INFINITE);

    CloseHandle(hReceiveThrd);
    CloseHandle(hParsingThrd);
    CloseHandle(hSendThrd);

    return 0;
}

ThreadSend의 경우 테스트를 위한 쓰레드이고 ThreadReceive는 수신을 위한 쓰레드입니다. ThreadParsing이 분리, 합쳐진 패킷을 기존 패킷으로 파싱하는 쓰레드입니다. ThreadSend의 첫번째 케이스에서는 패킷이 분할되는 상황, 두번째 케이스에서는 패킷이 합쳐지는 상황에 대해서 모의하였습니다. ThreadReceive에서는 TCP/IP 수신 후 데이터를 큐에 Push합니다. ThreadParsing에서는 큐를 확인하고 Pop하여 파싱으로 기존 전송 패킷을 수신한 후 처리합니다. 아래의 그림은ThreadParsing에서 패킷을 수신하기 위한 파싱 로직입니다.

패킷 수신 파싱 로직

테스트 결과는 아래의 그림과 같습니다.

테스트 결과

TCP/IP 통신 코드 헤더

#pragma once

#include <stdint.h>
#include <WinSock2.h>
#include "dataQueue.h"

#define RECV_BUFFER_SIZE (16384)
#define SERV_IP_ADDR ("127.0.0.1")

int32_t ServConnection(int16_t port, SOCKET* servSocket, SOCKET* clntSocket);
int32_t ServRecv(SOCKET* servSocket, SOCKET* clntSocket, ST_Queue* queue);
int32_t ClntConnection(int16_t port, SOCKET* clntSocket, char* ipAddr);
int32_t ClntRecv(SOCKET* socket, ST_Queue* queue);

TCP/IP 통신 코드

#include "tcpIpComm.h"

int32_t ServConnection(int16_t port, SOCKET* servSocket, SOCKET* clntSocket)
{
	int32_t result = FALSE;
	int32_t option = 1;
	SOCKADDR_IN servAddr, clntAddr;
	int32_t szClntAddr;

	do {
		*servSocket = socket(PF_INET, SOCK_STREAM, 0);

		if (*servSocket == INVALID_SOCKET) {
			break;
		}

		memset(&servAddr, 0, sizeof(servAddr));

		servAddr.sin_family = AF_INET;
		servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
		servAddr.sin_port = htons(port);

		if (bind(*servSocket, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR) {
			closesocket(*servSocket);
			break;
		}

		if (listen(*servSocket, 5) == SOCKET_ERROR) {
			closesocket(*servSocket);
			break;
		}

		szClntAddr = sizeof(clntAddr);
		*clntSocket = accept(*servSocket, (SOCKADDR*)&clntAddr, &szClntAddr);   // 클라이언트와 통신 할

		if (*clntSocket == INVALID_SOCKET) {
			closesocket(*clntSocket);
			closesocket(*servSocket);
			break;
		}
		else {
			result = TRUE;
			break;
		}
	} while (0);
	
	return result;
}

int32_t ServRecv(SOCKET* servSocket, SOCKET* clntSocket, ST_Queue* queue)
{
	int32_t result, len;
	static int8_t recvBuf[RECV_BUFFER_SIZE];

	len = recv(*clntSocket, recvBuf, RECV_BUFFER_SIZE, 0);

	if (len <= 0) {
		closesocket(*servSocket);
		closesocket(*clntSocket);
		result = FALSE;
	}
	else {
		QueueAddrPush(queue, recvBuf, len);
		result = TRUE;
	}

	return result;
}

int32_t ClntConnection(int16_t port, SOCKET* clntSocket, char * ipAddr)
{
	int32_t result = FALSE;

	SOCKADDR_IN servAddr;

	do {
		*clntSocket = socket(PF_INET, SOCK_STREAM, 0);

		if (*clntSocket == INVALID_SOCKET) {
			break;
		}

		servAddr.sin_family = AF_INET;
		servAddr.sin_addr.s_addr = inet_addr(ipAddr);
		servAddr.sin_port = htons(port);
		
		if (connect(*clntSocket, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR) {
			closesocket(*clntSocket);
			break;
		}
		else {
			result = TRUE;
			break;
		}

	} while (0);

	return result;
}

int32_t ClntRecv(SOCKET* socket, ST_Queue* queue)
{
	int32_t result, len;
	static int8_t recvBuf[RECV_BUFFER_SIZE];

	len = recv(*socket, recvBuf, RECV_BUFFER_SIZE, 0);

	if (len <= 0) {
		closesocket(*socket);
		result = FALSE;
	}
	else {
		QueueAddrPush(queue, recvBuf, len);
		result = TRUE;
	}

	return result;
}

데이터 큐 코드 헤더

#pragma once

#include <stdint.h>
#include <windows.h>

#define NO (0)
#define YES (!NO)

#define QUEUE_LENGTH (65536)

typedef struct {
    int32_t front;
    int32_t back;
    int32_t size;
    int32_t bufSize;
    int8_t* buf;

    CRITICAL_SECTION lock;
}ST_Queue;

int32_t IsQueueEmpty(ST_Queue* queue);
int32_t QueueSize(ST_Queue* queue);
int32_t IsQueueFull(ST_Queue* queue);
int32_t QueueInit(ST_Queue* queue, int32_t queueLength);
void QueueDelete(ST_Queue* queue);
void QueuePush(ST_Queue* queue, int8_t data);
void QueueAddrPush(ST_Queue* queue, int8_t* data, size_t dataSize);
int32_t QueuePop(ST_Queue* queue);
void QueueAddrPop(ST_Queue* queue, int8_t* data, size_t dataSize);

데이터 큐 코드

#include "dataQueue.h"

int32_t IsQueueEmpty(ST_Queue* queue)
{
    int32_t result;

    EnterCriticalSection(&queue->lock);
    if (queue->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }
    LeaveCriticalSection(&queue->lock);

    return result;
}

int32_t QueueSize(ST_Queue* queue)
{
    int32_t result;

    EnterCriticalSection(&queue->lock);
    result = queue->size;
    LeaveCriticalSection(&queue->lock);

    return result;
}

int32_t IsQueueFull(ST_Queue* queue)
{
    int32_t result;

    EnterCriticalSection(&queue->lock);
    if (queue->size == queue->bufSize) {
        result = YES;
    }
    else {
        result = NO;
    }
    LeaveCriticalSection(&queue->lock);

    return result;
}

int32_t QueueInit(ST_Queue* queue, int32_t queueLength)
{
    int32_t result;

    queue->buf = (int8_t*)malloc(sizeof(int8_t) * queueLength);

    if (queue->buf != NULL) {
        queue->front = 0;
        queue->back = 0;
        queue->size = 0;
        queue->bufSize = queueLength;
        memset(queue->buf, 0, (sizeof(int8_t) * queueLength));
        InitializeCriticalSection(&queue->lock);

        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

void QueueDelete(ST_Queue* queue)
{
    free(queue->buf);
    DeleteCriticalSection(&queue->lock);
}

void QueuePush(ST_Queue* queue, int8_t data)
{
    if (IsQueueFull(queue) == YES) {
        printf("queue is full\n");
    }
    else {
        EnterCriticalSection(&queue->lock);
        queue->buf[queue->back] = data;
        queue->back++;
        queue->size++;

        if (queue->back == queue->bufSize) {
            queue->back = 0;
        }
        LeaveCriticalSection(&queue->lock);
    }
}

void QueueAddrPush(ST_Queue* queue, int8_t* data, size_t dataSize)
{
    int32_t i;
    if (IsQueueFull(queue) == YES) {
        printf("queue is full\n");
    }
    else {
        EnterCriticalSection(&queue->lock);
        for (i = 0; i < dataSize; i++) {
            queue->buf[queue->back] = data[i];
            queue->back++;
            queue->size++;

            if (queue->back == queue->bufSize) {
                queue->back = 0;
            }
        }
        LeaveCriticalSection(&queue->lock);
    }
}

int32_t QueuePop(ST_Queue* queue)
{
    int8_t result = 0;

    if (IsQueueEmpty(queue) == YES) {
        printf("queue is emtpy\n");
    }
    else {
        EnterCriticalSection(&queue->lock);
        result = queue->buf[queue->front];
        queue->front++;
        queue->size--;

        if (queue->front == queue->bufSize) {
            queue->front = 0;
        }
        LeaveCriticalSection(&queue->lock);
    }

    return result;
}

void QueueAddrPop(ST_Queue* queue, int8_t* data, size_t dataSize)
{
    int32_t i;
    if (IsQueueEmpty(queue) == YES) {
        printf("queue is emtpy\n");
    }
    else {
        EnterCriticalSection(&queue->lock);
        for (i = 0; i < dataSize; i++) {
            data[i] = queue->buf[queue->front];
            queue->front++;
            queue->size--;

            if (queue->front == queue->bufSize) {
                queue->front = 0;
            }
        }
        LeaveCriticalSection(&queue->lock);
    }
}

이상으로 패킷 분리 및 합침을 고려한 TCP/IP 통신 수신 로직에 대한 설명을 마치겠습니다!

[c/c++] 프로세스 우선순위 변경

업글 — Fri, 10 Dec 2021 01:04:17 +0900

안녕하세요 업글입니다!

윈도우 운영체제는 리얼타임 OS가 아니기때문에 윈도우 환경에서 실행되는 프로세스의 경우 실시간으로 동작되는 것은 어렵습니다. 실시간이 중요한 경우 OS를 윈도우를 사용하지 않고 상대적으로 백그라운드에서 동작되는 프로세스가 적은 리눅스를 사용하거나 VxWorks와 같은 RTOS 종류의 운영체제를 사용하게 됩니다.

여기서는 윈도우 환경에서 프로세스를 최대한 실시간으로 운영하기 위한 방법에서 단순한 방법 중 하나인 프로세스 우선순위를 변경하는 방법에 대해서 설명드리겠습니다. 반대의 경우로 우선순위를 낮게 변경하는 경우에도 적용할 수 있습니다.

윈도우 프로그램 기본 우선순위

Visual Studio를 통해서 생성된 프로그램을 실행하였을 때 기본적인 우선순위는 보통입니다. 작업 관리자의 세부 정보에서 해당하는 프로그램의 우선순위 설정에서 확인할 수 있습니다.

프로세스 우선순위 변경에는 2가지 방법이 있습니다.

첫 번째 방법은 작업 관리자를 이용한 방법

위의 그림과 같이 해당하는 프로그램의 우선순위를 우선순위 설정에서 선택하여 변경할 수 있습니다.

쉽게 적용할 수 있지만 프로그램을 매번 실행할 때마다 프로세스 우선순위를 변경해야 하기 때문에 불편하여 현실적으로 사용 불가한 것으로 판단됩니다.

두 번째 방법은 Visual Studio에서 우선순위 변경 코드 사용

#include <stdio.h>
#include <stdint.h>
#include <windows.h>

int main()
{
	SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

	int32_t i = 0; 
	while (1) {
		printf("%d\n",i);
		Sleep(1000);
		i++;
	}

	return 0;
}

windows 헤더 파일을 선언하고 SetPriorityClass 함수를 사용하여 프로세스 우선순위를 변경할 수 있습니다. 첫 번째 인자에는 GetCurrentProcess함수를 수행하여 현재 프로세스를 입력하고, 두 번째 인자에 변경하고자 하는 우선순위를 입력하면 됩니다.

우선순위	PriorityClass
실시간(R)	REALTIME_PRIORITY_CLASS
높음(H)	HIGH_PRIORITY_CLASS
높은 우선 순위(A)	ABOVE_NORMAL_PRIORITY_CLASS
보통(N)	NORMAL_PRIORITY_CLASS
낮은 우선 순위(B)	BELOW_NORMAL_PRIORITY_CLASS
낮음(L)	IDLE_PRIORITY_CLASS

실시간(R) 설정을 위해서 REALTIME_PRIORITY_CLASS를 적용하는 경우 작업 관리자에서 확인하였을 때 프로세스 우선순위는 실시간(R)이 아닌 높음(H)로 설정됨을 확인하실 수 있습니다. Visual Studio의 프로젝트 속성에서 UAC 실행 수준을 requireAdministrator로 변경해야 실시간(R) 설정이 정상적으로 가능합니다. 아래의 그림 순서대로 적용하시면 됩니다.

1. 프로젝트 속성

2. 링커 > 매니페스트 파일 > UAC 실행 수준

저의 경우 최근 구현한 윈도우 프로그램에서 우선순위를 실시간으로 변경하여 간헐적으로 발생한 이더넷 통신 송수신 지연 문제(송수신 함수 수행 전 타 프로세스 연산 수행)를 해결한 경험이 있습니다. 이러한 경우와 같이 윈도우 환경에서 프로세스의 연산을 보다 빠르게 처리하고 싶은 분들에게 추천합니다. 그러나 타 프로세스에 영향에 있을 수 있으니 이 부분은 주의하셔서 적용하시면 될 것 같습니다.

[c언어/c++] 분기문(switch) 제거

업글 — Thu, 21 Jan 2021 01:03:06 +0900

안녕하세요 업글입니다. 이번 포스팅에서는 분기문(switch)를 제거하는 방법에 대해서 설명해보도록 하겠습니다.

분기문에 대한 설명

분기문은 조건에 따라서 각각 다른 코드를 실행하도록 합니다. if문, switch문이 조건에 따라서 실행되는 코드가 달라지기 때문에 분기문이라고 생각하시면 됩니다. 이러한 분기문은 코드 작성 시 필수적으로 사용해야하는 문법입니다. 그러나 분기 조건이 많아질수록 코드를 이해하기 어려워지므로 가독성이 떨어지게 됩니다.

분기문 코드

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

int main()
{
    int32_t data, result;

    result = 0;
    data = rand() % 4;

    switch (data) {
        case 0:
            result = data * 2;
            break;
        case 1:
            result = data * 3;
            break;
        case 2:
            result = data * 4;
            break;
        case 3:
            result = data * 5;
            break;
        default:
            break;
    }

    printf("data = %d, result = %d\n", data, result);

    return 0;
}

분기문 제거 이유

위의 분기문에 대한 설명과 같이 분기 조건이 많아질수록 코드가 복잡해져서 이해가 힘들어져서 코드의 가독성이 떨어지게됩니다. 분기문의 조건이 많아 복잡한 경우 분기문을 제거하여 코드 가독성을 증가시킬 수 있습니다.

분기문 제거 코드

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

int main()
{
    int32_t data, result;

    result = 0;
    data = rand() % 4;

    int32_t table[] = { data * 2, data * 3, data * 4, data * 5 };

    result = table[data];

    printf("data = %d, result = %d\n", data, result);

    return 0;
}

위에서 예시로 보여드린 분기문 코드를 참조테이블을 사용하여 제거한 코드입니다. 코드가 간결해졌으며, 분기 조건이 추가되는경우에도 table배열에 추가하고자 하는 로직을 넣어 쉽게 추가할 수 있습니다.

위의 예시에서는 분기 조건에 따라서 result함수의 값이 달라지게됩니다. 이와 다르게 분기 조건에 따라서 실행되는함수가 달리지게 되는 경우에는 함수포인터를 사용하여 분기문을 제거할 수 있습니다.

분기조건에 따라 실행되는 함수가 달라지는 코드

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

#define NO (0)
#define YES (!NO)

void FunctionA(void)
{
    printf("A\n");
}

void FunctionB(void)
{
    printf("B\n");
}

void FunctionC(void)
{
    printf("C\n");
}

void FunctionD(void)
{
    printf("D\n");
}

int main()
{
    int32_t data;
    data = rand() % 4;

    switch (data) {
        case 0:
            FunctionA();
            break;
        case 1:
            FunctionB();
            break;
        case 2:
            FunctionC();
            break;
        case 3:
            FunctionD();
            break;
        default:
            break;
    }

    return 0;
}

함수포인터를 이용한 분기문 제거 코드

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

#define NO (0)
#define YES (!NO)

void FunctionA(void)
{
    printf("A\n");
}

void FunctionB(void)
{
    printf("B\n");
}

void FunctionC(void)
{
    printf("C\n");
}

void FunctionD(void)
{
    printf("D\n");
}

int main()
{
    int32_t data;
    data = rand() % 4;

    void(*pFunc[])(void) = {FunctionA, FunctionB, FunctionC, FunctionD};
    
    pFunc[data]();

    return 0;
}

통신으로 데이터를 수신하는 경우에 메시지에 따라서 실행되는 함수가 달라지게 되는데 이러한 경우에 "함수포인터를 이용하여 분기를 제거하는 코드"를 유용하게 사용할 수 있습니다. 메시지의 개수가 많기 때문에 코드가 복잡해지며 메시지가 추가되는 경우에 메시지에 해당하는 처리 함수를 구현하고 함수포인터에 추가만 해주면 되기 때문입니다.

이상 분기문 제거에 대한 설명을 마치도록 하겠습니다.

[c언어] 스택(Stack)

업글 — Thu, 14 Jan 2021 07:54:24 +0900

안녕하세요 업글입니다! 이번 포스팅에서는 스택에 대해서 설명드리겠습니다.

스택에 대한 설명

스택은 입력된 데이터들을 저장하고 저장된 순서와 반대로 데이터를 출력하는 자료구조입니다. 큐의 가장 큰 특징은 먼저 들어온 데이터는 가장 마지막에 나가는 것입니다. 이것을 후입선출 또는 LIFO이라고 주로 표현합니다. 쉽게 예를 들어서 접시 쌓기를 생각하시면 될 것 같습니다. 가장 먼저 정리한 접시가 가장 아래에 쌓여있고 가장 최근에 정리한 접시가 가장 위에 쌓여있기 때문에 가장 최근 쌓은 접시를 가장 먼저 사용하게 되는 것과 같이 데이터가 관리되게 됩니다. 스택 또한 큐와 동일하게 배열과 링크드리스트를 사용하여 구현할 수 있습니다.

스택 사용 이유

스택은 dfs(depth first search)와 같은 알고리즘에서 사용되며 후입선출을 해야하는 상황에서 유용하게 사용하게 됩니다.

대표적인 예로 redo, undo가 있을 것입니다. 파워포인트에서 ctrl+z를 누르게 되면 현재 작성된 상황에서 이전 상황으로 돌아가게 됩니다. 이러한 상황을 구현할 때 스택을 유용하게 사용할 수 있습니다. 스택에 작성 데이터들을 순차적으로 입력해놓으면 ctrl+z를 누를때마다 스택에서 이전에 작성된 상황(가장 최근에 입력된 작성 데이터)을 쉽게 불러올 수 있을 것입니다.

또 이름에서부터 느껴지듯이 스택메모리에서도 사용됩니다. a, b라는 함수가 있고 a함수에서 b함수를 호출한다고 가정해보겠습니다.

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

#define NO (0)
#define YES (!NO)

void FunctionB()
{
    int32_t data[] = { 3, 4 };

    printf("FunctionB data1=%d, data2=%d, dataSum=%d\n", data[0], data[1], data[0] + data[1]);
}

void FunctionA()
{
    int32_t data[] = { 1, 2 };

    FunctionB();

    printf("FunctionA data1=%d, data2=%d, dataSum=%d\n", data[0], data[1], data[0] + data[1]);
}

int main()
{
    FunctionA();

    return 0;
}

FunctionA 호출 시 순서

1. FunctionA 호출

2. FunctionA의 data배열 스택에 저장

3. FunctionA의 현재주소(복귀주소) 스택에 저장

4. FucntionB 호출

5. FunctionB의 data배열 스택에 저장

6. FunctionB printf문 실행

7. FunctionB의 data배열 스택에서 삭제

8. FunctionA의 복귀주소 스택에서 읽기 및 삭제

9. FunctionA의 복귀주소로 복귀

10. FunctionA printf문 실행

11. Functionㅁ data배열 스택에서 삭제

위의 예시는 쉽게 설명하기 위한 예시이며 실제 함수가 분기될 때에는 추가적인 절차가 있음을 참고바랍니다.

배열을 이용한 스택 코드

typedef struct {
    int32_t* buf;
    uint32_t back;
    size_t size;
    size_t bufSize;
}ST_Stack;

int32_t StackInit(ST_Stack* stack, size_t stackSize)
{
    int32_t result;

    stack->buf = (int32_t*)malloc(sizeof(int32_t) * stackSize);

    if (stack->buf == NULL) {
        result = NO;
    }
    else {
        stack->back = 0;
        stack->size = 0;
        stack->bufSize = stackSize;

        result = YES;
    }
    
    return result;
}

void StackDelete(ST_Stack* stack)
{
    free(stack->buf);
    stack->back = 0;
    stack->size = 0;
    stack->bufSize = 0;
}

int32_t IsStackEmpty(ST_Stack* stack)
{
    int32_t result;

    if (stack->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }
    
    return result;
}

int32_t IsStackFull(ST_Stack* stack)
{
    int32_t result;

    if (stack->size == stack->bufSize) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

void StackPush(ST_Stack* stack, int32_t data)
{
    if (IsStackFull(stack) == YES) {
        printf("stack is full\n");
    }
    else {
        stack->buf[stack->back] = data;
        stack->back++;
        stack->size++;
    }
}

int32_t StackPop(ST_Stack* stack)
{
    int32_t result = 0;

    if (IsStackEmpty(stack) == YES) {
        printf("stack is empty\n");
    }
    else {
        stack->back--;
        result = stack->buf[stack->back];
        stack->size--;
    }

    return result;
}

void StackPrint(ST_Stack* stack)
{
    int32_t i;

    for (i = 0; i < stack->size; i++) {
        printf("i=%d, %d\n", i, stack->buf[i]);
    }
}

int main()
{
    #define STACK_SIZE (8)
    #define POP_SIZE (4)

    ST_Stack stack;
    int32_t i;
    int32_t popData[POP_SIZE];

    StackInit(&stack, STACK_SIZE);

    StackPop(&stack);

    for (i = 0; i < STACK_SIZE; i++) {
        StackPush(&stack, i);
    }
    StackPush(&stack, 8);

    StackPrint(&stack);
    
    for (i = 0; i < POP_SIZE; i++) {
        popData[i] =  StackPop(&stack);
        printf("pop=%d\n", popData[i]);
    }

    StackPrint(&stack);
}

링크드리스트를 이용한 스택 코드

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

#define NO (0)
#define YES (!NO)

typedef struct ST_Node {
    int32_t data;
    struct ST_Node* next;
    struct ST_Node* prev;
}ST_Node;

typedef struct {
    ST_Node* front;
    ST_Node* back;
    int32_t size;
}ST_Stack;

int32_t IsStackEmpty(ST_Stack* stack)
{
    int32_t result;

    if (stack->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

int32_t StackInit(ST_Stack* stack)
{
    int32_t result = YES;

    stack->front = NULL;
    stack->back = NULL;
    stack->size = 0;

    return result;
}

void StackDelete(ST_Stack* stack)
{
    int32_t i;
    ST_Node* temp;

    for (i = 0; i < stack->size; i++) {
        temp = stack->front;
        stack->front = stack->front->next;
        free(temp);
    }

    stack->front = NULL;
    stack->back = NULL;
    stack->size = 0;
}

void StackPush(ST_Stack* stack, int32_t data)
{
    ST_Node* addNode;

    addNode = (ST_Node*)malloc(sizeof(ST_Node));

    if (addNode == NULL) {
        printf("heap is full\n");
    }
    else {
        addNode->data = data;
        addNode->next = NULL;

        if (IsStackEmpty(stack) == YES) {
            addNode->prev = NULL;
            stack->front = addNode;
            stack->back = addNode;
        }
        else {
            addNode->prev = stack->back;
            stack->back->next = addNode;
            stack->back = addNode;
        }
        stack->size++;
    }
}

int32_t StackPop(ST_Stack* stack)
{
    int32_t result = 0;
    ST_Node* del;

    if (IsStackEmpty(stack) == YES) {
        printf("stack is emtpy\n");
    }
    else {
        result = stack->back->data;
        del = stack->back;
        stack->back = stack->back->prev;
        stack->size--;

        free(del);
    }

    return result;
}

void StackPrint(ST_Stack* stack)
{
    int32_t i;
    ST_Node* temp;

    temp = stack->front;
    for (i = 0; i < stack->size; i++) {
        printf("i=%d, %d\n", i, temp->data);
        temp = temp->next;
    }
}

int main()
{
#define POP_SIZE (4)

    ST_Stack stack;
    int32_t i;
    int32_t popData[POP_SIZE];

    StackInit(&stack);

    StackPop(&stack);

    StackPush(&stack, 0);
    StackPop(&stack);

    for (i = 0; i < STACK_SIZE; i++) {
        StackPush(&stack, i);
    }

    StackPrint(&stack);

    for (i = 0; i < POP_SIZE; i++) {
        popData[i] = StackPop(&stack);
        printf("pop=%d\n", popData[i]);
    }

    StackPrint(&stack);
}

이상 스택에 대한 설명을 마치도록 하겠습니다.

[c언어] 링크드리스트(Linked List)

업글 — Wed, 13 Jan 2021 06:39:40 +0900

안녕하세요 업글입니다! 이번 포스팅에서는 링크드리스트에 대해서 설명드리겠습니다.

링크드리스트에 대한 설명

각 노드끼리 연결되어 자료를 관리하는 자료구조입니다. 포인터를 통해서 노드에서 다른노드를 가르킴으로써 노드끼리 연결할 수 있습니다. 그러므로 각 노드에는 노드를 가르킬 수 있는 포인터를 포함하고 있습니다.

링크드리스트 구조 예

링크드리스트를 이해하기 위해서는 포인터, 힙, 동적 메모리 할당에 대한 이해가 필요합니다.

각각에 대해서 간단하게 설명하도록 하겠습니다.

1) 포인터

포인터란 메모리의 주소를 저장할 수 있는 변수입니다.

변수를 선언 시 해당 변수는 메모리의 어떠한 영역에 위치하게 됩니다. 이 때 어떤 영역에 위치하는 지 표현 하는 것이 주소입니다. 각 변수는 유일한 주소를 가지게 됩니다. 포인터가 주소를 저장하는 것을 주소를 가르킨다라고 표현하기도 합니다. 그러므로 포인터는 가리키는 메모리의 주소를 통해서 해당 주소의 변수에 접근하여 값을 읽어오거나 수정할 수 있습니다. 링크드리스트에서는 노드 포인터를 통해서 연결하고자 하는 노드의 주소를 가르키게 됩니다.

2) 힙과 동적 메모리 할당

변수 메모리

힙은 메모리영역 중 하나로 프로그램이 실행되며 필요한 만큼 할당하여 사용할 수 있는 메모리 영역을 말합니다. 힙 영역에서 사용 할 메모리를 할당받는 것을 동적 메모리 할당이라고 합니다. malloc을 통해서 동적 메모리 할당을 하며 할당받은 메모리를 해제하기 위해서는 free를 사용하게 됩니다. 동적 메모리 할당 후 할당된 메모리 영역을 미 사용 시에는 free를 통해서 무조건 해제 해야 한다는 점 주의바랍니다.

프로그램 실행 시에 사용 해야 할 메모리의 크기가 결정되는 상황에서 동적 메모리 할당이 필요하게 됩니다. 링크드리스트는 데이터가 입력될 때 노드를 힙 영역에 할당하고 삭제할 때 노드를 힙 영역에서 해제하게 됩니다. 그러므로 링크드리스트는 배열과 다르게 프로그램 실행 시에 크기가 변경될 수 있으며 힙 영역에서 사용할 공간이 있을 때 까지 크기를 증가시킬 수 있다는 장점이 있습니다.

메모리 측면에서 링크드리스트

링크드리스트 종류

링크드리스트는 단일 연결 리스트(Singly Linked List)와 이중 연결 리스트(Doubly Linked List)로 나눌 수 있습니다. 이는 단방향 연결리스트, 양방향 연결리스트로도 표현되곤 합니다. 단일 연결 리스트는 노드가 1개의 노드를 가르키는 구조이지만 이중 연결 리스트는 노드가 2개의 노드를 가리키는 구조입니다. 단일 연결 리스트는 한방향으로 탐색할 수 있지만 이중 연결 리스트는 양방향으로 탐색할 수 있다는 장점이 있습니다.

단일 연결 리스트 구조

이중 연결 리스트 구조

링크드리스트 사용 이유

링크드리스트는 데이터 삽입 및 삭제가 빈번하게 일어나는 경우 주로 사용할 수 있습니다. 어레이 리스트와 비교했을 때 어레이 리스트의 경우 중간 인덱스에 데이터를 삽입하거나 삭제해야하는 경우 삽입 및 삭제 후 데이터들을 1인덱스씩 이동 시켜 줘야 하기 때문에 연산시간이 오래 걸리게됩니다.

링크드리스트의 경우 데이터 삽입 시 노드를 추가하고 해당하는 위치에서 기존 노드들의 연결을 끊고 기존노드들과 새로운 노드에 연결하면됩니다. 데이터 삭제 시 이전 노드와 다음 노드를 연결하고 해당 노드를 해제하여 삭제하면 됩니다.그러나 탐색 시 이진 탐색(bineary search)과 같은 방법을 사용할 수 없고 순차적으로 진행해야하며 인덱스 참조가 불가능하고 순차적으로 노드를 이동해가며 데이터의 값을 읽어 와야 된다는 단점이 있습니다.

단일 연결리스트 코드

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

#define NO (0)
#define YES (!NO)

typedef struct ST_Node {
    int32_t data;
    struct ST_Node* next;
}ST_Node;

typedef struct ST_LinkedList {
    int32_t size;
    ST_Node* front;
    ST_Node* back;
}ST_LinkedList;

void LinkedListInit(ST_LinkedList * linkedList)
{
    linkedList->size = 0;
    linkedList->front = NULL;
    linkedList->back = NULL;
}

void LinkedListDelete(ST_LinkedList* linkedList)
{
    int32_t i;
    ST_Node* del;

    for(i = 0; i < linkedList->size; i++){
        del = linkedList->front;
        linkedList->front = linkedList->front->next;
        free(del);
    }

    LinkedListInit(linkedList);
}

int32_t IsLinkedListEmpty(ST_LinkedList* linkedList)
{
    int32_t result;

    if (linkedList->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

void LinkedListFrontPush(ST_LinkedList* linkedList, int32_t data)
{
    ST_Node* add;

    add = (ST_Node*)malloc(sizeof(ST_Node));

    if (add == NULL) {
        printf("heap is full\n");
    }
    else {
        add->data = data;
        add->next = linkedList->front;
        linkedList->front = add;

        if (IsLinkedListEmpty(linkedList) == YES) {
            linkedList->back = add;
        }

        linkedList->size++;
    }
}

int32_t LinkedListFrontPop(ST_LinkedList* linkedList)
{
    int32_t result = 0;
    ST_Node* del;

    if (IsLinkedListEmpty(linkedList) == YES) {
        printf("linkedlist is empty\n");
    }
    else {
        result = linkedList->front->data;
        del = linkedList->front;
        linkedList->front = linkedList->front->next;
        free(del);
        linkedList->size--;
    }

    return result;
}

void LinkedListBackPush(ST_LinkedList* linkedList, int32_t data)
{
    ST_Node* add;

    add = (ST_Node*)malloc(sizeof(ST_Node));

    if (add == NULL) {
        printf("heap is full\n");
    }
    else {
        add->data = data;
        add->next = NULL;
       
        if (IsLinkedListEmpty(linkedList) == YES) {
            linkedList->front = add;
            linkedList->back = add;
        }
        else {
            linkedList->back->next = add;
            linkedList->back = add;
        }
        linkedList->size++;
    }
}

int32_t LinkedListBackPop(ST_LinkedList* linkedList)
{
    int32_t result = 0;
    ST_Node* temp;

    if (IsLinkedListEmpty(linkedList) == YES) {
        printf("linkedlist is empty\n");
    }
    else {
        result = linkedList->back->data;
        temp = linkedList->front;

        while (temp->next != NULL && temp->next->next != NULL) {
            temp = temp->next;
        }
        temp->next = NULL;
        free(linkedList->back);

        linkedList->back = temp;
        linkedList->size--;
    }

    return result;
}

void LinkedListInsertion(ST_LinkedList* linkedList, uint32_t position, int32_t data)
{
    int32_t i;
    ST_Node* add;
    ST_Node* cur;

    if (position > linkedList->size) {
        printf("position error\n");
    }
    else if (position == 0) {
        LinkedListFrontPush(linkedList, data);
    }
    else if (position == linkedList->size) {
        LinkedListBackPush(linkedList, data);
    }
    else {
        add = (ST_Node*)malloc(sizeof(ST_Node));

        if (add == NULL) {
            printf("heap is full\n");
        }
        else {
            cur = linkedList->front;
            for (i = 1; i < position; i++) {
                cur = cur->next;
            }
            add->data = data;
            add->next = cur->next;
            cur->next = add;         
            linkedList->size++;
        }
    }
}

int32_t LinkedListPop(ST_LinkedList* linkedList, uint32_t position)
{
    int32_t result = 0;
    int32_t i;
    ST_Node* cur, *del;

    if (IsLinkedListEmpty(linkedList) == YES) {
        printf("linkedlist is empty\n");
    }
    else {
        if (position >= linkedList->size) {
            printf("position error\n");
        }
        else if (position == 0) {
            result = LinkedListFrontPop(linkedList);
        }
        else if (position == linkedList->size-1) {
            result = LinkedListBackPop(linkedList);
        }
        else {
            cur = linkedList->front;
            for (i = 1; i < position; i++) {
                cur = cur->next;
            }
            result = cur->next->data;
            del = cur->next;
            cur->next = cur->next->next;
            free(del);
            linkedList->size--;
        }
    }

    return result;
}

void LinkedListPrint(ST_LinkedList* linkedList)
{
    ST_Node* cur;
    int32_t i;

    cur = linkedList->front;
    for (i = 0; i < linkedList->size; i++) {
        printf("i=%d, data=%d\n", i, cur->data);
        cur = cur->next;
    }
}


int main()
{
    ST_LinkedList linkedList;
    int32_t i;
    int32_t data[3];

    LinkedListInit(&linkedList);

    for (i = 0; i < 2; i++) {
        LinkedListFrontPush(&linkedList, i);
        LinkedListBackPush(&linkedList, i);
    }
    LinkedListInsertion(&linkedList, 1, 10);
    LinkedListInsertion(&linkedList, 3, 30);

    LinkedListPrint(&linkedList);
    printf("\n");

    data[0] = LinkedListPop(&linkedList, 4);
    data[1] = LinkedListFrontPop(&linkedList);
    data[2] = LinkedListBackPop(&linkedList);

    LinkedListPrint(&linkedList);
    
    printf("popData = %d, %d, %d\n", data[0], data[1], data[2]);

    LinkedListDelete(&linkedList);

    return 0;
}

이중 연결 리스트 코드

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

#define NO (0)
#define YES (!NO)


typedef struct ST_Node {
    int32_t data;
    struct ST_Node* next;
    struct ST_Node* prev;
}ST_Node;

typedef struct ST_LinkedList {
    int32_t size;
    ST_Node* front;
    ST_Node* back;
}ST_LinkedList;

void LinkedListInit(ST_LinkedList* linkedList)
{
    linkedList->size = 0;
    linkedList->front = NULL;
    linkedList->back = NULL;
}

void LinkedListDelete(ST_LinkedList* linkedList)
{
    int32_t i;
    ST_Node* del;

    for (i = 0; i < linkedList->size; i++) {
        del = linkedList->front;
        linkedList->front = linkedList->front->next;
        free(del);
    }

    LinkedListInit(linkedList);
}

int32_t IsLinkedListEmpty(ST_LinkedList* linkedList)
{
    int32_t result;

    if (linkedList->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

void LinkedListFrontPush(ST_LinkedList* linkedList, int32_t data)
{
    ST_Node* add;

    add = (ST_Node*)malloc(sizeof(ST_Node));

    if (add == NULL) {
        printf("heap is full\n");
    }
    else {
        add->data = data;
        add->prev = NULL;
        
        if (IsLinkedListEmpty(linkedList) == YES) {
            add->next = NULL;
            linkedList->back = add;
        }
        else {
            add->next = linkedList->front;
            linkedList->front->prev = add;
        }
        linkedList->front = add;
        linkedList->size++;
    }
}

int32_t LinkedListFrontPop(ST_LinkedList* linkedList)
{
    int32_t result = 0;
    ST_Node* del;

    if (IsLinkedListEmpty(linkedList) == YES) {
        printf("linkedlist is empty\n");
    }
    else {
        result = linkedList->front->data;
        del = linkedList->front;
        linkedList->front = linkedList->front->next;
        if (linkedList->front != NULL) {
            linkedList->front->prev = NULL;
        }
        free(del);
        linkedList->size--;
    }

    return result;
}

void LinkedListBackPush(ST_LinkedList* linkedList, int32_t data)
{
    ST_Node* add;

    add = (ST_Node*)malloc(sizeof(ST_Node));

    if (add == NULL) {
        printf("heap is full\n");
    }
    else {
        add->data = data;
        add->next = NULL;
        
        if (IsLinkedListEmpty(linkedList) == YES) {
            add->prev = NULL;
            linkedList->front = add;
        }
        else {
            add->prev = linkedList->back;
            linkedList->back->next = add;
        }
        linkedList->back = add;
        linkedList->size++;
    }
}

int32_t LinkedListBackPop(ST_LinkedList* linkedList)
{
    int32_t result = 0;
    ST_Node* del;

    if (IsLinkedListEmpty(linkedList) == YES) {
        printf("linkedlist is empty\n");
    }
    else {
        result = linkedList->back->data;
        
        del = linkedList->back;
        linkedList->back = linkedList->back->prev;
        if (linkedList->back != NULL) {
            linkedList->back->next = NULL;
        }
        free(del);

        linkedList->size--;
    }

    return result;
}

void LinkedListInsertion(ST_LinkedList* linkedList, uint32_t position, int32_t data)
{
    int32_t i;
    ST_Node* add;
    ST_Node* cur;

    if (position > linkedList->size) {
        printf("position error\n");
    }
    else if (position == 0) {
        LinkedListFrontPush(linkedList, data);
    }
    else if (position == linkedList->size) {
        LinkedListBackPush(linkedList, data);
    }
    else {
        add = (ST_Node*)malloc(sizeof(ST_Node));

        if (add == NULL) {
            printf("heap is full\n");
        }
        else {
            if (position <= linkedList->size / 2) {
                cur = linkedList->front;
                for (i = 0; i < position; i++) {
                    cur = cur->next;
                }    
            }
            else {
                cur = linkedList->back;
                int32_t loop = linkedList->size - position;
                for (i = 1; i < loop; i++) {
                    cur = cur->prev;
                }
            }
            add->data = data;
            add->next = cur;
            add->prev = cur->prev;

            cur->prev = add;
            add->prev->next = add;
            linkedList->size++;
        }
    }
}

int32_t LinkedListPop(ST_LinkedList* linkedList, uint32_t position)
{
    int32_t result = 0;
    int32_t i;
    ST_Node* cur;

    if (IsLinkedListEmpty(linkedList) == YES) {
        printf("linkedlist is empty\n");
    }
    else {
        if (position >= linkedList->size) {
            printf("position error\n");
        }
        else if (position == 0) {
            result = LinkedListFrontPop(linkedList);
        }
        else if (position == linkedList->size - 1) {
            result = LinkedListBackPop(linkedList);
        }
        else {
            if (position <= linkedList->size / 2) {
                cur = linkedList->front;
                for (i = 0; i < position; i++) {
                    cur = cur->next;
                }
            }
            else {
                cur = linkedList->back;
                int32_t loop = linkedList->size - position;
                for (i = 1; i < loop; i++) {
                    cur = cur->prev;
                }
            }
            result = cur->data;
            cur->next->prev = cur->prev;
            cur->prev->next = cur->next;
            free(cur);
            linkedList->size--;
        }
    }

    return result;
}

void LinkedListPrint(ST_LinkedList* linkedList)
{
    ST_Node* cur;
    int32_t i;

    cur = linkedList->front;
    for (i = 0; i < linkedList->size; i++) {
        printf("i=%d, data=%d\n", i, cur->data);
        cur = cur->next;
    }
}


int main()
{
    ST_LinkedList linkedList;
    int32_t i;
    int32_t data[3];

    LinkedListInit(&linkedList);

    for (i = 0; i < 2; i++) {
        LinkedListFrontPush(&linkedList, i);
        LinkedListBackPush(&linkedList, i);
    }
    LinkedListInsertion(&linkedList, 1, 10);
    LinkedListInsertion(&linkedList, 3, 30);

    LinkedListPrint(&linkedList);
    printf("\n");

    data[0] = LinkedListPop(&linkedList, 4);
    data[1] = LinkedListFrontPop(&linkedList);
    data[2] = LinkedListBackPop(&linkedList);

    LinkedListPrint(&linkedList);

    printf("popData = %d, %d, %d\n", data[0], data[1], data[2]);

    LinkedListDelete(&linkedList);

    return 0;
}

[c언어] 큐(Queue)

업글 — Fri, 1 Jan 2021 17:08:27 +0900

안녕하세요 업글입니다! 이번 포스팅에서는 큐에 대해서 설명해보도록 하겠습니다.

자료구조 중 하나인 큐(Queue)는 많은 분들이 알고계시고 프로그래밍을 막 시작하신 분들도 한번쯤은 들어봤을만한 대표적인 자료구조 중 하나라고 생각합니다.

큐에 대한 설명

큐는 입력된 데이터들을 순서대로 저장하고 순서대로 출력하는 자료구조입니다. 큐의 가장 큰 특징은 먼저 들어온 데이터는 먼저 나가는 것입니다. 이것을 선입선출 또는 FIFO이라고 주로 표현합니다. 쉽게 예를 들어서 맛집에서 줄서기를 생각하시면 될 것 같습니다. 먼저 온 사람이 맛집에 먼저 들어가고 나중에 온 사람이 나중에 들어가는 것과 같이 데이터가 관리되게 됩니다.

큐 사용 이유

큐는 bfs(breath first search)와 같은 탐색 알고리즘 등에서 사용되기도 하지만 즉시 처리하지 못하는 상황에 주로 사용됩니다. 비동기 시스템에서 주로 사용된다고 생각하시면 될 것 같습니다.

비동기 통신을 예시로 설명하겠습니다.

A쓰레드에서는 데이터를 송신하고 B쓰레드에서는 데이터를 수신하여 쓰레드 간 통신하는 경우로 가정하겠습니다. 이 때 데이터를 송신하는 시점과 수신하는 시점이 달라서 비동기인 상황에서는 데이터를 송신했을 때 수신하는 쓰레드에서 수신 데이터를 즉시 처리할 수 없습니다. 이러한 상황에서 A쓰레드에서 데이터들을 큐에 입력하고 B쓰레드에서는 처리 가능한 시간에 큐에서 데이터를 출력하여 처리함으로써 비동기 상황에서 데이터를 문제없이 수신하여 처리할 수 있습니다.

이러한 경우 뿐만 아니라 데이터가 수신될 때 수신된 데이터 파싱과 같은 작업을 즉시 처리할 수 있는 시간이 부족한 경우 큐에 데이터만 입력하고 데이터가 수신되지 않거나 여유있는 시간에 큐에서 데이터를 출력하여 문제없이 처리 할 수 있습니다.

큐 구현 방법

큐는 배열과 링크드리스트를 사용하여 구현할 수 있습니다. 배열의 경우 선형큐와 원형큐로 구분할 수 있지만 선형큐의 경우 사용하기에 적절하지 않기 때문에 원형큐를 사용하게 됩니다. c++의 경우 STL을 사용하여 쉽게 검증된 큐를 사용하실 수 있습니다.

1. 배열을 통해 원형큐를 구현하는 경우

back값은 데이터가 입력 되어야 할 인덱스 위치, front값은 데이터가 출력 되어야 할 인덱스 위치입니다. 마지막 인덱스까지 데이터를 입력하거나 출력했을 때(back값 또는 front값이 마지막 인덱스 값일 때)는 다시 첫번째 인덱스(back값 또는 front값이 0)에 데이터를 입력하거나 출력하도록 구현합니다. 최대로 입력될 수 있는 크기를 고려하여 배열을 크기를 선정하는 것이 중요합니다.

아래의 그림은 큐 크기가 4인 큐에 데이터를 1 ~ 5까지 push하고 pop을 한번하는 과정입니다.

2. 링크드리스트를 통해 큐를 구현하는 경우

front가 가르키는 노드를 출력하고 back의 다음 노드에 입력된 노드를 연결하여 구현하도록 합니다. front는 가장 앞의 노드를 가르키게 되며 back은 가장 마지막의 노드를 가르키게 됩니다. 데이터를 입력할 때는 마지막 노드의 뒤에 추가된 데이터 노드를 이어서 입력하게 되고, 데이터를 출력할 때는 첫번째 노드의 데이터를 출력하고 다음 노드를 첫번째 노드로 가르키도록 합니다. 링크드리스트를 통해서 큐를 구현하면 큐의 최대 크기를 고려하지 않고 구현할 수 있는 장점이 있습니다.

아래의 그림은 큐에 1 ~ 3까지 push하고 1번 pop을 한번하는 과정입니다.

배열을 이용한 큐 코드

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

#define NO (0)
#define YES (!NO)

typedef struct {
    int32_t front;
    int32_t back;
    int32_t size;
    int32_t bufSize;
    int32_t* buf;
}ST_Queue;

int32_t IsQueueEmpty(ST_Queue * queue)
{
    int32_t result;

    if (queue->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

int32_t IsQueueFull(ST_Queue* queue)
{
    int32_t result;

    if (queue->size == queue->bufSize) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

int32_t QueueSize(ST_Queue* queue)
{
    int32_t result;

    result = queue->size;

    return result;
}

int32_t QueueInit(ST_Queue* queue, int32_t queueLength)
{
    int32_t result;

    queue->buf = (int32_t*)malloc(sizeof(int32_t) * queueLength);

    if (queue->buf != NULL) {
        queue->front = 0;
        queue->back = 0;
        queue->size = 0;
        queue->bufSize = queueLength;
        memset(queue->buf, 0, (sizeof(int32_t) * queueLength));
        result = YES;
    }
    else {
        result = NO;
    }
    
    return result;
}

void QueueDelete(ST_Queue* queue)
{
    free(queue->buf);
}

void QueuePush(ST_Queue* queue, int32_t data)
{
    if (IsQueueFull(queue) == YES) {
        printf("queue is full\n");
    }
    else {
        queue->buf[queue->back] = data;
        queue->back++;
        queue->size++;

        if (queue->back == queue->bufSize) {
            queue->back = 0;
        }
    }
}

int32_t QueuePop(ST_Queue* queue)
{
    int32_t result = 0;

    if (IsQueueEmpty(queue) == YES) {
        printf("queue is emtpy\n");
    }
    else {
        result = queue->buf[queue->front];
        queue->front++;
        queue->size--;

        if (queue->front == queue->bufSize) {
            queue->front = 0;
        }
    }

    return result;
}

int main()
{
    #define QUEUE_LENGTH (4)

    ST_Queue queue;
    int32_t i, data, loop;

    if (QueueInit(&queue, QUEUE_LENGTH) == NO) {
        printf("queue init fail\n");
    }

    /* push test */
    for (i = 0; i < QUEUE_LENGTH; i++) {
        QueuePush(&queue, i);
        printf("pushData = %d, queueSize = %d\n", i, QueueSize(&queue));
    }

    data = QUEUE_LENGTH;
    QueuePush(&queue, data);
    printf("pushData = %d, queueSize = %d\n", data, QueueSize(&queue));

    /* pop test */
    loop = QueueSize(&queue);
    for (i = 0; i < loop; i++) {
        data = QueuePop(&queue);
        printf("popData = %d, queueSize = %d\n", data, QueueSize(&queue));
    }
    
    data = QueuePop(&queue);
    printf("popData = %d, queueSize = %d\n", data, QueueSize(&queue));

    return 0;
}

링크드리스트를 이용한 큐 코드

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

#define NO (0)
#define YES (!NO)

typedef struct ST_Node{
    int32_t data;
    ST_Node* next;
}ST_Node;

typedef struct {
    ST_Node* front;
    ST_Node* back;
    int32_t size;
}ST_Queue;

int32_t IsQueueEmpty(ST_Queue* queue)
{
    int32_t result;

    if (queue->size == 0) {
        result = YES;
    }
    else {
        result = NO;
    }

    return result;
}

int32_t QueueSize(ST_Queue* queue)
{
    int32_t result;

    result = queue->size;

    return result;
}

int32_t QueueInit(ST_Queue* queue)
{
    int32_t result = YES;

    queue->front = NULL;
    queue->back = NULL;
    queue->size = 0;    

    return result;
}

void QueueDelete(ST_Queue* queue)
{
    int32_t i;
    ST_Node* temp;

    for (i = 0; i < queue->size; i++) {
        temp = queue->front;
        queue->front = queue->front->next;
        free(temp);
    }

    queue->front = NULL;
    queue->back = NULL;
    queue->size = 0;
}

void QueuePush(ST_Queue* queue, int32_t data)
{
    ST_Node* addNode;

    addNode = (ST_Node*)malloc(sizeof(ST_Node));

    if (addNode == NULL) {
        printf("heap is full\n");
    }
    else {
        addNode->data = data;
        addNode->next = NULL;

        if (IsQueueEmpty(queue) == YES) {
            queue->front = addNode;
            queue->back = addNode;
        }
        else {
            queue->back->next = addNode;
            queue->back = addNode;
        }
        queue->size++;
    }
}

int32_t QueuePop(ST_Queue* queue)
{
    int32_t result = 0;
    ST_Node* del;

    if (IsQueueEmpty(queue) == YES) {
        printf("queue is emtpy\n");
    }
    else {
        result = queue->front->data;
        del = queue->front;
        queue->front = queue->front->next;
        queue->size--;

        free(del);
    }

    return result;
}

int main()
{
#define QUEUE_LENGTH (4)

    ST_Queue queue;
    int32_t i, data, loop;

    if (QueueInit(&queue) == NO) {
        printf("queue init fail\n");
    }

    /* push test */
    for (i = 0; i < QUEUE_LENGTH; i++) {
        QueuePush(&queue, i);
        printf("pushData = %d, queueSize = %d\n", i, QueueSize(&queue));
    }

    /* pop test */
    loop = QueueSize(&queue);
    for (i = 0; i < loop; i++) {
        data = QueuePop(&queue);
        printf("popData = %d, queueSize = %d\n", data, QueueSize(&queue));
    }
    
    data = QueuePop(&queue);

    QueueDelete(&queue);

    return 0;
}

이상 큐에 대한 설명을 마치겠습니다.

c언어/c++ do while(0)

업글 — Mon, 21 Dec 2020 23:51:13 +0900

안녕하세요 업글입니다! 이번 포스팅에서는 do while(0)에 대해서 설명드리겠습니다.

do while문에 대해서 모르시는 분은 아래의 포스팅을 먼저 읽어보시는 것을 추천드립니다.

2020/12/18 - [분류 전체보기] - c언어/c++ do while문

c언어/c++ do while문

안녕하세요 업글입니다. 이번 포스팅에서는 do while문에 대해서 설명드리겠습니다. do while문에 대한 설명 while문에 대해서 잘 모르시는 분은 지난번 포스팅한 while문에 대해서 먼저 읽어보시는 것

elevate-yourself.tistory.com

do while(0)에 대한 설명

do while(0)는 조건이 무조건 거짓이기 때문에 해당하는 코드를 반복하지 않고 1회만 수행하게 됩니다. 이렇게 되면 do while(0)를 사용하지 않고 일반적으로 코드를 작성하는 것과 동일한 결과를 출력하게 됩니다. 그런데 왜 do while(0)를 사용하는 것일까요? 제가 생각했을 때는 2가지 경우가 있습니다. 첫번째로는 코드의 가독성, 두번째는 매크로 함수 구현입니다. 하나씩 상세하게 설명드리도록 하겠습니다.

코드의 가독성

순차적으로 정상임을 확인 해야 하는 경우를 예시로 설명 드리겠습니다.

파일을 3개 open하는 코드를 예시로 들겠습니다. 설명을 위하여 약간 억지(?)인 것 같기도 합니다만 아래와 같은 경우의 정상인지 비정상인지 확인하는 코드를 작성하는 경우는 꽤나 많다고 생각합니다.

#include <stdio.h>
#include <stdint.h>

#define FILE_NUM (3)
#define NORMAL (-1)

int main()
{
	FILE* fp[FILE_NUM];
	uint32_t errorFile = NORMAL;

	fp[0] = fopen("file0.txt", "r");

	if (fp[0] != NULL) {
		fp[1] = fopen("file1.txt", "r");

		if (fp[1] != NULL) {
			fp[2] = fopen("file2.txt", "r");

			if (fp[2] != NULL) {
				// 로직
			}
			else {
				errorFile = 2;
			}
		}
		else {
			errorFile = 1;
		}
	}
	else {
		errorFile = 0;
	}

	printf("errorFile = %d", errorFile);

	return 0;
}

0번 파일이 정상적으로 open되었을 때 1번 파일을 open하고 1번 파일이 정상적으로 open되었을 때 2번 파일을 open하고 2번 파일이 정상적으로 open되었을 때 어떠한 로직을 실행하는 코드입니다. if문 안에 if문이 있고 또 if문이 있어서 코드의 가독성이 떨어지는 편입니다.

이러한 경우 do while(0)과 break문을 사용하여 깔끔하게 표현할 수 있습니다.

#include <stdio.h>
#include <stdint.h>

#define FILE_NUM (3)
#define NORMAL (-1)

int main()
{
	FILE* fp[FILE_NUM];
	uint32_t errorFile = NORMAL;

	do {
		fp[0] = fopen("file0.txt", "r");

		if (fp[0] == NULL) {
			errorFile = 0;
			break;
		}

		fp[1] = fopen("file1.txt", "r");

		if (fp[1] == NULL) {
			errorFile = 1;
			break;
		}

		fp[2] = fopen("file2.txt", "r");

		if (fp[2] == NULL) {
			errorFile = 2;
			break;
		}
	} while (0);

	// 로직

	printf("errorFile = %d", errorFile);

	return 0;
}

위의 코드와 동일한 동작을 하게 되지만 if문이 중첩되지 않기 때문에 코드의 가독성이 좋아지게 됩니다. 또한 do while(0) 내부에서만 사용되는 변수가 있는 경우 do while(0) 내부에서 변수를 선언하여 사용함으로써 코드를 보다 깔끔하게 작성할 수 있습니다. 이러한 경우에 do while(0)를 사용하는 것을 추천드립니다.

매크로 함수 구현

저는 오픈소스에서 do while(0)를 사용하여 매크로함수를 작성하는 것을 많이 봐왔습니다. 왜 매크로 함수 구현 시 do while(0)를 사용하는지 설명드리겠습니다.

#include <stdio.h>
#include <stdint.h>

#define MACRO_FUNCTION_ADD(a, b, c) printf("a=%d, b=%d, c=%d\n", a, b, c);\
									c = a + b;\
									printf("c = %d\n", c)

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (0)
		MACRO_FUNCTION_ADD(a, b, c);
	

	return 0;
}

위와 같이 구현했을 때 전처리기 결과는 아래와 같이 되게 됩니다. 이는 코드가 의도한 바와 다르게 동작하게 됩니다.

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (0)
		printf("a=%d, b=%d, c=%d\n", a, b, c);
		c = a + b;
		printf("c = %d\n", c);
	

	return 0;
}

결과

의도한 바는 if 조건이 참인 경우 printf("a=%d, b=%d, c=%d\n", a, b, c) / c = a+b / printf("c = %d\n", c) 3줄의 코드를 실행하고 if 조건이 거짓인 경우 모든 줄의 코드가 실행되지 않아야합니다. 그러나 if 조건이 참인 경우에는 의도한 바와 같이 동작하지만 if 조건이 거짓인 경우 c = a+b / printf("c = %d\n", c) 2줄의 코드만 실행하게되어 의도한 바와 다르게 코드가 실행되게 됩니다.

또한, 아래의 코드와 같이 else가 있는 경우 컴파일러 에러가 발생하게 됩니다.

#include <stdio.h>
#include <stdint.h>

#define MACRO_FUNCTION_ADD(a, b, c) printf("a=%d, b=%d, c=%d\n", a, b, c);\
									c = a + b;\
									printf("c = %d\n", c)

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (0)
		MACRO_FUNCTION_ADD(a, b, c);
	else
		printf("else\n");

	return 0;
}

그러면 아래와 같이 { }를 추가하여 코드를 수정한 후 실행 해보도록 하겠습니다.

#include <stdio.h>
#include <stdint.h>

#define MACRO_FUNCTION_ADD(a, b, c)	{\
										printf("a=%d, b=%d, c=%d\n", a, b, c); \
										c = a + b; \
                                        printf("c = %d\n", c); \
									}

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (1)
		MACRO_FUNCTION_ADD(a, b, c);
		
	return 0;
}

if(1) 결과

if(0) 결과

if가 참, 거짓인 경우 모두 의도한 바와 같이 동작하게 됩니다.

그러나 아래의 코드는 위에서 컴파일러 에러가 발생하는 코드와 같이 동일하게 에러가 발생하게 됩니다.

#include <stdio.h>
#include <stdint.h>

#define MACRO_FUNCTION_ADD(a, b, c)	{\
										printf("a=%d, b=%d, c=%d\n", a, b, c); \
										c = a + b; \
                                        printf("c = %d\n", c); \
									}

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (1)
		MACRO_FUNCTION_ADD(a, b, c);
	else
		printf("else\n");
    
	return 0;
}

do while(0)를 사용하여 매크로 함수를 작성한 후 코드를 실행해보도록 하겠습니다.

#include <stdio.h>
#include <stdint.h>

#define MACRO_FUNCTION_ADD(a, b, c) do{\
										printf("a=%d, b=%d, c=%d\n", a, b, c);\
										c = a + b;\
										printf("c = %d\n", c);\
									}while(0)

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (1)
		MACRO_FUNCTION_ADD(a, b, c);
		
	return 0;
}

if(1) 결과

if(0) 결과

if가 참, 거짓인 경우 모두 의도한 바와 같이 동작하게 됩니다.

또한, do while(0)를 사용하면 아래의 코드에서 컴파일러 에러가 발생하지 않고 코드가 의도한 대로 동작하게 됩니다.

#include <stdio.h>
#include <stdint.h>

#define MACRO_FUNCTION_ADD(a, b, c) do{\
										printf("a=%d, b=%d, c=%d\n", a, b, c);\
										c = a + b;\
										printf("c = %d\n", c);\
									}while(0)

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (1)
		MACRO_FUNCTION_ADD(a, b, c);
	else
		printf("else\n");
        
	return 0;
}

if(1) 결과

if(0) 결과

do while(0)를 제외하고 위의 2가지 경우에서도 아래의 코드와 같이 if와 else에 { }만 추가해준다면 코드가 의도한 대로 동작되고 컴파일 에러가 발생하지 않습니다.

#define MACRO_FUNCTION_ADD(a, b, c)		printf("a=%d, b=%d, c=%d\n", a, b, c); \
										c = a + b; \
										printf("c = %d\n", c)

//#define MACRO_FUNCTION_ADD(a, b, c)		{\
										printf("a=%d, b=%d, c=%d\n", a, b, c); \
										c = a + b; \
										printf("c = %d\n", c); \
										}

int main()
{
	int32_t a, b, c;
	a = 1;
	b = 2;
	c = 0;

	if (0) {
		MACRO_FUNCTION_ADD(a, b, c);
	}
	else{
		printf("else\n");
	}
		
	return 0;
}

그러나 사용자에 따라서 if에 코드가 한줄만 실행되는 경우 { }를 생략하고 작성하는 경우가 있기 때문에 매크로 함수를 작성하실 때는 do while(0)를 필수적으로 사용하는 것을 추천드립니다.

또한, if문 사용 시 코드가 한줄만 실행되더라도 { }를 사용하여 코드를 작성하시는 것을 추천드립니다. 위와 같은 상황을 미리 방지하기 위함입니다. 코드가 간결할 때는 이러한 문제를 쉽게 찾을 수 있지만 코드가 복잡해지면 많은 시간을 낭비할수도 있기 때문입니다.

이상 do while(0)에 대한 설명을 마치도록 하겠습니다!

c언어/c++ do while문

업글 — Fri, 18 Dec 2020 00:28:47 +0900

안녕하세요 업글입니다. 이번 포스팅에서는 do while문에 대해서 설명드리겠습니다.

do while문에 대한 설명

while문에 대해서 잘 모르시는 분은 지난번 포스팅한 while문에 대해서 먼저 읽어보시는 것을 추천드립니다.

2020/12/17 - [분류 전체보기] - c언어/c++ while문

c언어/c++ while문

안녕하세요 업글입니다. 이번 포스팅에서는 반복문중 하나인 while문에 대해서 설명 드리도록 하겠습니다. while문에 대한 설명 c언어 및 c++에서 반복문은 while문, do while문, for문이 있습니다. 이 반

elevate-yourself.tistory.com

do while문은 while문과 거의 동일하나 하나의 차이가 있습니다. while전에 do가 있듯이 반복하기 전에 뭔가를 해라라는 의미입니다. 즉, while문처럼 반복하기 전에 먼저 코드를 수행하고 반복하게 됩니다.

do while문 동작

위의 그림처럼 ①에서 먼저 코드를 실행하고 ②에서 조건을 확인한 후 다시① 코드를 실행하고 다시②으로 이동하는 것을 반복하고 거짓인 경우 ③으로 이동하여 do while문을 탈출하게 됩니다.

또 한번 강조하지만 중요한점은 먼저 무조건 코드를 실행한 후 조건을 확인한다는 점입니다.

문법적으로 while(조건)뒤에 세미클론을 붙여줘야 한다는점도 꼭 기억하시길 바랍니다. 세미클론이 없으면 컴파일러에서 에러로 출력하게됩니다.

do while문 예제

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


int main()
{
	int32_t value = 0;

	do {
		printf("value = %d\n", value);

		value++;
	} while (value == 0);

	printf("do while후 value = %d\n", value);

	return 0;
}

위의 코드에서 value가 1일 때 value == 0의 조건에서 거짓이기 때문에 printf와 value++을 1번만 실행하고 do while문을 탈출하게 됩니다.

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


int main()
{
	int32_t value = 0;

	do {
		printf("value = %d\n", value);

		value++;
	} while (value == 1);

	printf("do while후 value = %d\n", value);

	return 0;
}

위의 코드에서는 value가 1이 되고 value == 1의 조건에서 참이기 때문에 do while구문을 1회더 반복 실행한 후 value가 2가되어 조건이 거짓이 되기 때문에 do while문을 탈출하게 됩니다.

do while문에서 break 키워드

while문 포스팅에서 설명한 것처럼 break 키워드는 반복문을 탈출하는 키워드입니다. do while의 경우도 while문과 동일하게 break 키워드의 위치에 오게되면 do while문을 바로 탈출하게 됩니다.

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


int main()
{
	int32_t value = 0;

	do {
		printf("value = %d\n", value);
		
		if (value == 0) {
			break;
		}
		value++;
	} while (value == 1);

	printf("do while후 value = %d\n", value);

	return 0;
}

위의 코드에서 value의 초기 값은 0이므로 break문을 만나게 됩니다. break문을 만나고 바로 do while문을 탈출하게 되므로 밑의 코드(value++)은 실행되지 않게됩니다.

do while문에서 continue 키워드

while문 포스팅에서 설명한 것처럼 continue 키워드는 반복문의 조건을 다시 확인하는키워드입니다. 그러므로 do while의 경우도 while문과 동일하게 continue 키워드를 만나게 되면 조건을 확인하는 위치인 while(조건)으로 이동하게 됩니다.

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


int main()
{
	int32_t value = 0;
	int32_t continueCount = 0;

	do {
		printf("value = %d, continueCount = %d\n", value, continueCount);
		if (continueCount == 3) {
			break;
		}

		if (value == 0) {
			continueCount++;
			continue;
		}
		value++;
	} while (value == 0);

	printf("do while후 value = %d, continueCount = %d\n", value, continueCount);

	return 0;
}

위의 코드에서 value는 0이기때문에 continue문을 만나게됩니다. continue후 while(value == 0);으로 바로 이동하기 때문에 value++은 실행되지 않습니다. 그러므로 총 continue를 3회 만나고 조건을 3회 확인한 후 continueCount가 3일 때 break를 만나게되어 do while반복문을 탈출하게 됩니다.

이상 do while문에 대한 설명을 마치겠습니다.

c언어/c++ while문

업글 — Thu, 17 Dec 2020 23:53:34 +0900

안녕하세요 업글입니다. 이번 포스팅에서는 반복문중 하나인 while문에 대해서 설명 드리도록 하겠습니다.

while문에 대한 설명

c언어 및 c++에서 반복문은 while문, do while문, for문이 있습니다. 이 반복문들 중에서 while문에 대해서 설명드리겠습니다.

while문은 조건이 참인 경우 해당하는 코드를 수행하고 조건이 거짓일 때까지 코드를 반복적으로 수행하게 됩니다.

while문 동작

위의 그림과 같이 while문은 ①에서 조건을 확인하고 참인 경우 ②의 코드를 실행하고 다시①으로 이동하는 것을 반복하고 거짓인 경우 ③으로 이동하여 while문을 탈출하게 됩니다.

while문 예제

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


int main()
{
	int32_t value = 0;

	while (value < 5) {
		printf("value = %d\n", value);
		value++;
	}

	return 0;
}

위의 코드에서 value가 0, 1, 2, 3, 4일 때는 참이기 때문에 printf문을 실행하고 value를 1씩 증가시킵니다. value가 5가되고 조건이 거짓이 되기때문에 while문을 탈출하게 됩니다.

break 키워드

break 키워드는 반복문을 탈출하는 키워드입니다. while문을 반복 실행하다가 break문의 위치에 오게되면 바로 while문을 탈출하게 됩니다.

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


int main()
{
	int32_t value = 0;

	while (1) {
		printf("value = %d\n", value);

		if (value == 5) {
			break;
		}
		value++;
	}

	return 0;
}

위의 코드에서 while(1)이기 때문에 조건은 항상 참이므로 무한 반복하게 됩니다. 그러나 value가 5일 때 break문을 만나기때문에 바로 while문을 탈출하게 됩니다. break문의 밑에 코드(value++)는 수행되지 않게 됩니다. 그러므로 결과에서 break후 value값은 5가 되게 됩니다.

continue 키워드

continue 키워드는 반복문의 조건을 다시 확인하는 키워드입니다. while문을 반복 실행하다가 continue키워드의 위치에 오게되면 while문의 조건을 확인하는 위치로 이동하여 조건을 다시 확인하게 됩니다.

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


int main()
{
	int32_t value = 0;
	int32_t continueCount = 0;

	while (1) {
		printf("value = %d, continueCount = %d\n", value, continueCount);

		if (continueCount == 3) {
			break;
		}

		if (value == 3) {
			continueCount++;
			continue;
		}
		value++;
	}

	printf("break후 value = %d, continueCount = %d\n", value, continueCount);

	return 0;
}

위의 코드에서 value가 3일때 continue 키워드를 만나게 됩니다. continue 키워드를 만나게되면 밑의 코드(value++)는 실행되지 않으며 while(1)의 위치로 이동하여 조건을 재확인하게됩니다. while문을 탈출한 후에 value의 값은 3이 되게 됩니다. continue의 경우 해당하는 조건에 아래의 코드를 실행하지 않게할 때 사용 하실 수 있습니다.

이상 while문과 break, continue문에 대한 설명을 마치도록 하겠습니다.

c언어/c++ if 조건문

업글 — Thu, 17 Dec 2020 00:40:14 +0900

안녕하세요 업글입니다. 이번 포스팅에서 if 조건문에 대해서 설명드리겠습니다.

개인적인 생각으로 if문은 c언어 및 c++뿐만아니라 모든 프로그래밍 언어에서 가장 중요한? 없어서는 안되는? 중요하고 필수적으로 쓰여야 하는 문법이라고 생각합니다. 학부 시절에 포인터와 같은 초보자가 알지 못하고 이해하기 힘든 문법이 많은 상황에서도 조건문과 반복문을 통해서 대부분의 기능을 구현 했었던 기억이 있습니다.

if 조건문에 대한 설명

if 조건문은 괄호안의 조건이 참인 경우 if 조건문에 해당하는 코드를 실행하게 됩니다.

if(조건){
	// 조건이 참인 경우 { } 안의 코드 실행
}

여기서 조건이 참이냐 거짓이냐를 판단하는 기준은 if(0)인 경우 거짓이고 if(0외에 숫자)인 경우 참입니다.

if(참){
	// { } 안에 있는 코드가 실행된다.
}

if(거짓){
	// { } 안에 있는 코드가 실행되지 않는다.
}
// 해당 위치에서 코드 실행 시작

조건이 참인 경우 { }안에 있는 코드들이 실행되며 조건이 거짓인 경우 { }안에 있는 코드들이 실행되지 않고 { } 아래에서 코드 실행이 시작되게 됩니다.

간단한 예제 코드를 보면서 설명드리겠습니다.

#include <stdio.h>
#include <stdint.h>

int32_t Getvalue() 
{
	int32_t result;

	result = 0;

	return result;
}


int main()
{
	int32_t value;

	value = Getvalue();

	if (value == 0) {
		printf("value = 0\n");
	}

	if (value == 1) {
		printf("value = 1\n");
	}

	return 0;
}

위의 코드에서 value는 0이기 때문에 첫번째 조건문에서는 참이고 두번째 조건문에서는 거짓이므로 아래의 그림과 같은 결과를 출력하게 됩니다.

if, else if, else에 대한 설명

if를 사용하여 해당하는 조건일 때만 if문의 { } 내부 코드를 실행 할 수 있습니다. 여러 조건이 필요한 경우에 어떻게 나타낼수 있을까요? 아래의 코드와 같이 if문을 여러 개 사용하여 나타낼 수 있습니다.

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

int32_t Getvalue()
{
	int32_t result;

	result = rand() % 3;

	return result;
}


int main()
{
	int32_t value;

	value = Getvalue();

	if (value == 0) {
		printf("value = 0\n");
	}

	if (value == 1) {
		printf("value = 1\n");
	}

	if (value == 2) {
		printf("value = 2\n");
	}

	return 0;
}

위의 코드에서는 value가 0, 1, 2일 때 각각 조건에 대하여 if문을 사용하였습니다.

위의 코드에서 value가 0이라고 가정했을 때 첫번째 if문에서 참이기 때문에 해당하는 코드를 실행하게됩니다. 두번째, 세번째 if문에서는 value가 0이기 때문에 거짓이지만 조건을 확인하게 됩니다. 이러한 경우에 if, else if, else를 사용하여 처리할 수 있습니다.

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

int32_t Getvalue()
{
	int32_t result;

	result = rand() % 3;

	return result;
}


int main()
{
	int32_t value;

	value = Getvalue();

	if (value == 0) {
		printf("value = 0\n");
	}
	else if (value == 1) {
		printf("value = 1\n");
	}
	else{
		printf("value = 2\n");
	}

	return 0;
}

if, else if, else를 사용했을 때 value가 0이 아닌 경우 그 다음 else if 조건인 value가 1인지 확인하고 1이면 해당하는 코드를 실행하고 value가 1이 아닌 경우 else에 해당하는 코드를 실행하게 됩니다.

if만 사용하는 경우와 다르게 value가 0인 경우 if문의 조건이 참이기 때문에 해당하는 코드만 실행하고 else if, else에 대한 조건은 확인하지 않습니다.

단락평가(short circuit evaluation)에 대한 설명

(1 || 0) // 첫번째 항에서 이미 1이기 때문에 || 뒤의 조건은 확인하지 않고 1로 출력
(0 && 1) // 첫번째 항에서 이미 0이기 때문에 && 뒤의 조건은 확인하지 않고 0으로 출력

위의 코드에서 보듯이 단락평가란 ||연산자를 사용하는 경우 첫번째 항에서 1이면 뒤의 조건에 관계없이 1이되기 때문에뒤의 조건을 확인하지 않고 1을 출력하며 &&연산자를 사용하는 경우 첫번째 항에서 0이면 뒤의 조건에 관계없이 0이되기 때문에 뒤의 조건을 확인하지 않고 0을 출력하는 것입니다.

if 조건문에서 ||, &&연산자를 사용하여 조건식을 구성하는 경우가 많으므로 단락평가를 고려하여 보다 코드를 효율적으로 작성하실 수 있습니다.

아래의 코드를 통해서 설명드리겠습니다.

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


int main()
{
	int32_t value = 0;
	int32_t count = 0;

	// value가 0이므로 첫번째 항이 참이 되기 때문에 || 뒤의 조건 실행 X
	if (value == 0 || (count = 1)) {
		printf("|| short circuit evaluation\n");
	}

	// value가 0이므로 첫번째 항이 거짓이 되기 때문에 || 뒤의 조건 실행 X
	if (value == 1 && (count = 1)) {
		printf("&& short circuit evaluation\n");
	}
	
	printf("count = %d\n", count);

	return 0;
}

단락평가로 인해서 첫번째 if문에서 value == 0은 참이기 때문에 || 뒤의 조건을 실행하지 않게되고 두번째 if문에서 value == 1은 거짓이기 때문에 && 뒤의 조건을 실행하지 않게됩니다. count가 0인 것을 보아 뒤의 조건을 실행하지 않은 것을 확인할 수 있습니다. 그러므로 ||를 사용하는 경우 참이 될 가능성이 높은 조건을 앞에 작성하고 &&를 사용하는 경우 거짓이 될 가능성이 높은 조건을 뒤에 작성하면 보다 효율적으로 속도를 빠르게 할 수 있습니다. PC와 같은 환경에서는 큰 차이가 없으므로 고민하지 않아도 되지만, 가격이 저렴한 MCU와 같은 하드웨어에서 속도를 최적화 해야하는 경우 적용을 할 수도 있을 것 같습니다.

if 조건문 사용 시 주의 사항

if문에서 ==연산자를 사용하는 경우 실수로 ==대신 =을 입력할 수 있습니다. 이러한 경우 if문은 의도하지 않은 동작을 하게 됩니다. "= 0"인 경우 무조건 거짓으로 판단되며 "= 0이외 숫자"인 경우 무조건 거짓으로 판단하게 됩니다. 이러한 경우 컴파일러에서 오류로 출력해주지만 에러로 출력해주지 않기 때문에 주의할 필요가 있습니다.

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


int main()
{
	int32_t value = 0;

	// 의도한 코드 : value == 0
	if (value = 0) {
		printf("value가 0이므로 무조건 실행되지 않는다.");
	}

	// 의도한 코드 : value == 1
	if (value = 1) {
		printf("value가 1이므로 무조건 실행된다.");
	}

	// 실수를 예방하기 위한 코드
	// 0 = value가 되면 오류 출력
	if (0 == value) {

	}

	// 실수를 예방하기 위한 코드
	// 1 = value가 되면 오류 출력
	if (1 == value) {

	}

	return 0;
}

위의 코드에서 첫번째, 두번째 if문은 실수로 인해서 작성된 코드이고 첫번째 if문은 무조건 실행될 수 없으며 두번째 if문은 무조건 실행되게 됩니다.

이러한 실수를 예방하기 위해서 상수를 왼쪽에 두는 방법이 있습니다. 상수를 왼쪽에 두게 되면 상수는 변경될 수 없기 때문에 에러가 발생되게 됩니다. 그러나 보편적으로 상수를 오른쪽으로 두기 때문에 가독성은 조금 떨어질 것으로 생각됩니다.

if문을 포함한 if/else if/else, 단락평가, if문 주의사항에 대한 포스팅은 이상 마치도록 하겠습니다.