:: 게임개발자 놀이터 , 시리시안

안녕하세요. 게임 개발자 놀이터입니다.

이번 포스팅에선 C#에서 C++에서 비교적 자주 쓰이는 (저는 편해서 자주 쓰는..) typedef를 C#에서 사용하는 방법입니다.

최근 C#을 사용하면서 비교적 KeyValuePair를 되게 자주 사용하게 됬습니다.

특정 2개의 값을 묶어서 관리하기 위해서였죠. 근데 KeyValuePair가 많아지면 어느게 어떤건지 변수명만으로 구분하기가 애매해 질때가 있었습니다.

그때 생각난게 C++의 typedef 였죠.

이름을 바꿔주면 편하지않을까..

생각하면서 typedef를 입력해봤으나 역시나 안됬습니다.

다른 방법이 없을까 찾아보면서 MSDN에 들어가게 됬습니다 (링크)

링크에 적힌 원문을 그대로 가져오면

typedef 키워드입니다. C++에서 typedef는 짧게 만들어지거나 이미 선언된 형식에서 좀 더 편리한 이름으로 사용됩니다. C#의 경우 using 지시문이 이 기능을 제공합니다.

라고 합니다.

그럼 예제 코드를 볼까요.

위 처럼 사용할수 있습니다.

무조껀 클래스 상단에 위치해야 합니다. 그렇지 않으면 에러를 뽑아내게 됩니다.

물론 최상단에 적어야 하는게 맞겠지만.. C언어가 생각나네요..

몇번 사용하다가 결국엔 새로 클래스를 만들어 사용했습니다.

그래도 참고가 될까 이곳에 글을 남깁니다.

감사합니다.

------------------------------

추가

C++도 템플릿 에일리어스(C++11)로 using 키워드를 사용할 수 있습니다.

기존 typedef 해석 방법은 구식(C와 호환)이라 템플릿 사용 시 문제가 있어서 C 코드와 호환이 필요하지 않다면 typedef 대신 using을 쓰는 걸 권장한다고합니다.

라고합니다. (링크로 남긴 페북을 통해 답글 중.)

안녕하세요. 게임개발자 놀이터 입니다.

이번 포스팅에선 퀵 정렬에 대해 정리해보려고 해요.

퀵정렬 (Quick Sort)

퀵정렬은 '찰스 앤터니 리처드 호어(1962)'가 개발한 정렬 알고리즘 이라고 합니다.

퀵 정렬은 기준(pivot)을 선택하여 기준보다 작은 데이터를 왼쪽에 위치시키고, 큰 데이터는 오른쪽에 위치시킵니다.

이 과정이 끝나면 기준(pivot)이 된 요소는 정렬된 위치를 찾습니다. 결과적으로 기준보다 작은 데이터는 왼쪽, 큰 데이터는 오른쪽에 위치하게됩니다. 이러한 알고리즘을 pivot을 기준으로 왼쪽 데이터 그룹과 오른쪽 데이터 그룹에 재귀적으로 더이상 불가능 할때까지 반복합니다. (데이터 그룹의 갯수가 0 이거나 1개일때까지 반복)

반복이 종료되면 정렬된 데이터 그룹을 얻을 수 있습니다.

(출처 : 위키백과 퀵정렬)

정렬과정

임의의 데이터 배열을 가지고 정렬 해보겠습니다.

15 13 9 10 26 24 85

1. 먼저 Pivot을 설정합니다.

15 13 9 10 26 24 85

2. Pivot(15)를 기준으로 보다 작으면 왼쪽, 크면 오른쪽에 위치시켜 분할합니다

13 9 03 15 26 24 85

3. 좌 우 로 분할된 데이터로 다시 (1,2)의 과정을 실행합니다.

( 13 9 10 )   15   ( 26 24 85 )

( 13 9 10 )   15   ( 26 24 85 )

( 9 10 13 )   15   ( 26 24 85 )

( 9 10 )   13 15   ( 26 24 85 )

2개의 함수와 재귀함수를 이용한 방법

1개의 재귀 함수를 이용한 방법

알고리즘 분석

가장 평균의 상황에서의 시간복잡도가 알고리즘의 시간 복잡도라고 할 수 있다.

크게 2가지 상황을 추축할수있다.

1. 최고의 경우, 나누어지는 족족 마다 반씩 분할되는 경우.

2. 최악의 경우, 나누어지는 족족마다 1개와 나머지로 분할되는 경우.

우선 1번의 경우를 계산하면. 

횟수 = (2ⁿ - 1) + 2 x (2ⁿ-¹ - 1) ...

= ⁿ-¹Σ 2... 이거 수식을 어떻게 적어야 할지 모르겠다..

계산하면.. NLogN이 나온다.

2번의 경우는 N² 이 나온다.

나중에 수식을 제대로 추가할수있는 방법을 알게된다면.. 그때 수정 해야겠다.

쨋든 2번의 경우는 극단적인 상황이므로, 시간 복잡도는 1번의 경우를 사용해서 O(N logN) 이다.

감사합니다.

동영상 예시

출처 : 유투브동영상

안녕하세요. 게임 개발자 놀이터입니다.

이번 포스팅에선 선택 정렬에 대해서 정리해보려고해요.

벌써 버블, 삽입 2개를 하고 선택정렬할 차례네요..

간단한건 이제 끝나가는군요.

선택 정렬

선택 정렬은 크게 3가지 방법으로 정렬을 합니다.

1. 주어진 배열에서 최솟값을 찾는다.

2. 그 값을 배열 맨앞에 위치한 값과 교체한다.

3. 맨 처음 위치를 뺀 나머지 배열을 같은 방법으로 교체한다.

정렬 과정

우선 랜덤하게 숫자를 배열해보겠습니다.

9 5 4 3 8 1 7

우선 정렬이 안된 배열 {9 5 4 3 8 1 7} 에서 최 하위 값을 찾습니다.

1 이군요. 찾은 값을 젤 처음 값과 교체합니다.

9 5 4 3 8 1 7 => 1 5 4 3 8 9 7

이렇게 한번의 루프가 끝났습니다.

두번째는 맨 처음 값 그러니까 교체가 된 1을 제외한 배열을 정렬합니다.

1 { 5 4 3 8 9 7 } 에서 최 하위 값을 찾습니다. 3 이군요. 1을 제외한 배열 처음과 교체합니다.

1 3 4 5 8 9 7 이 되겠군요.

이런식으로 마지막까지 진행하면 정렬이 됩니다.

밑의 그림을 참고해주세요.

(출처 : 위키백과 선택정렬)

예제 코드

간단하게 구현했습니다.

알고리즘 분석

선택 정렬은 최소값을 구하기 위해 전부 비교를 해야합니다. 따라서

(n-1) + (n-2) + ..... + 2 + 1 = n(n-1)/2 가 됩니다.

빅 오 표기법으로 시간 복잡도는 O(N²)가 되겠습니다.

그림 예시 자료

(출처:  위키백과 선택정렬 )

동영상 예시 자료

( 출처 : Youyube )

감사합니다.

안녕하세요. 게임개발자 놀이터 입니다.

이번 포스팅에선 삽입 정렬에 대하여 정리 해보려합니다.

삽입 정렬 ( Insertion Sort )

삽입 정렬은 자료 배열의 모든 요소를 앞에서부터 차례대로 이미 정렬된 배열 부분과 비교하여 자신의 위치를 찾아 삽입해서 정렬하는 알고리즘 입니다.

삽입 정렬의 경우 첫번째 요소를 이미 정렬됬다. 라고 간주 한 후 정렬을 시작합니다.

정렬되지않은 요소는 목록의 제일 뒤에있는 요소 부터 정렬된 목록과 비교하여 적절한 위치에 삽입합니다.

이 작업을 끝까지 반복하면 모든 요소가 정렬됩니다.

말로만 설명하면 좀 어려울수 있습니다.

정렬 과정

간단하게 삽입 정렬 예시를 보여드리겠습니다.

아래와 같이 5개의 숫자가 주어졌다고 했을때, 삽입 정렬로 정렬 해보겠습니다.

4 9 2 5 7

삽입정렬은 첫번째 요소는 정렬이 되었다고 판단하고, 두번째 부터 시작합니다.

첫번째

4 / □ 2 5 7  | key 값 = 9

9는 4보다 크니까 4보다 뒤쪽에 위치한다. 4 □ 2 5 7 

4 / 9 2 5 7 

두번째

4 9 / □ 5 7 | key 값 = 2

2는 9보다 작으니까 9보다 앞 쪽에 위치한다. 4 □ 9 5 7 

2는 4보다 작으니까 4보다 앞 쪽에 위치한다. □ 4 9 5 7

2 4 / 9 5 7

세번째

2 4 9 / □ 7 | key 값 = 5

5는 9보다 작으니까 9보다 앞쪽에 위치한다. 2 4 □ 9 7

5는 4보다 크니까 4보다 뒤쪽에 위치한다. 2 4 □ 9 7

2 4 5 / 9 7

네번째

2 4 5 9 / □ | key 값 = 7

7은 9보다 작으니까 9보다 앞쪽에 위치한다. 2 4 5 □ 9

7은 5보다 크니까 5보다 뒤쪽에 위치한다. 2 4 5 □ 9

2 4 5 7 9

정렬이 완료 되었습니다.

이처럼 첫번째 값을 제외하고 key 값으로 돌아가며 정렬이 완료된 부분과 비교하며 삽입을 하면 됩니다.

(사진 출처 : 나무위키 삽입정렬)

예제 코드

간단하게 구현했습니다.

알고리즘 분석

비교 횟수

삽입정렬은 두번째 요소부터 첫 요소와 비교하여 정렬한후 세번째 요소는 두번째와 첫번째와 비교합니다.

물론 이미 정렬되어있다면 비교를 하지 않겠지만, 빅오 표기법으로 생각하여 최악의 경우는 전부 비교하는겁니다.

0 + 1 + 2 + 3 .... + n-2 + n-1 = n(n-1)/2 가 되겠군요.

따라서 최악의 경우 시간 복잡도는 O(N²) 가 되겠습니다.

최선의 경우는 비교는 O(1)이고 for문이 Length-1 만큼 돌아야하니 O(n)이겠군요.

밑의 자료는 제가 삽입정렬에 대한 자료를 찾다가 발견한 자료들입니다.

삽입 정렬의 이미지 예시 

( 출처 : 위키 백과 : 삽입 정렬 )

삽입 정렬의 동영상 예시

출처 ( 유투브 동영상(클릭) )

감사합니다.

안녕하세요. 게임 개발자 놀이터입니다.

이번 포스팅에선 버블 정렬에 대하여 설명해보려고 합니다.

버블 정렬 ( Bubble Sort )

버블 정렬 ( Bubble Sort )은 인접한 두 수 를 비교하여 큰 수를 뒤로 보내는 간단한 정렬 알고리즘입니다.

시간 복잡도는 O(N²)을 가지고 있습니다. 속도는 느린 편 이지만, 코드가 단순 해서 자주 언급됩니다.

원소의 이동이 꼭 거품이 수면으로 올라오는듯한 모습을 보이기 때문에 Bubble sort 라는 이름을 가지게 되었다고 합니다.

정렬 과정

간단하게 버블 정렬의 예시를 보여드리겠습니다.

아래와 같이 5개의 숫자가 주어졌다고 했을때,  Bubble Sort로 정렬 해보겠습니다.

9 5 1 3 7

먼저 첫번째 인덱스와 두번째 인덱스를 비교합니다.

9와 5, 9가 더 크므로 두 수 의 자리를 바꿉니다.

교제 전 : 9 5 1 3 7

교체 후 : 5 9 1 3 7

다음 인덱스를 하나 늘려서 두번째 인덱스와 세번째 인덱스를 비교합니다.

9와 1, 9가 더 크므로 두 수의 자리를 바꿉니다.

교체 전 : 5 9 1 3 7

교체 후 : 5 1 9 3 7

계속해서 인덱스를 늘려가며 값을 비교하고 자리를 바꿔줍니다.

교체 전 : 5 1 9 3 7

교체 후 : 5 1 3 9 7

교체 전 : 5 1 3 9 7

교체 후 : 5 1 3 7 9

이렇게 한번의 순회가 끝났습니다. 한바퀴의 순회가 끝나니까 가장 큰 수인 9는 자리 자리를 찾아갔습니다.

그럼 다음 순회에선 맨 마지막 원소는 방문할 필요가 없어졌네요.

맨 마지막 원소인 9는 고정하고 나머지 원소도 진행 해봅시다.

교체 전 : 5 1 3 8 9

교체 후 : 1 5 3 7 9

교체 전 : 1 5 3 7 9

교체 후 : 1 3 5 7 9

교체 전 : 1 3 5 7 9

교체 후 : 1 3 5 7 9

두번째 순회가 끝났네요. 예시로 랜덤하게 적은 숫자가 2번의 순회 만으로 정렬이 완료되어버렸네요.

그래도 어느정도 느낌을 잡힐꺼라 생각합니다.

이런게 바로 버블 정렬입니다! 하하

원소들이 큰 순서대로 뒤로 밀려가서 거품처럼 정렬되는 모습이었습니다.

예제 코드

간단하게 구현했습니다.

알고리즘 분석

정렬 알고리즘은 분석을 할 필요가 있습니다.

제가 위에 시간 복잡도가 O(N²)라고 적어두긴 했지만 어떻게 구하는지도 알아야 합니다.

비교 횟수

버블 정렬은 한번의 순회를 마칠때마다 비교 대상이 하나씩 줄어듭니다.

전체 원소 갯수를 n개 라고 하면 총 n-1번의 순회를 돌면 정렬이 끝나게 됩니다.

5개의 원소 배열을 정렬한다면 4+3+2+1 = 10번 비교 하게 됩니다.

이를 수식화 하게되면

(n-1) + (n-2) + (n-3) + ... + 3 + 2 + 1 = ( n-1 ) * n / 2 = n(n-1)/2

이렇게 됩니다.

자리 교환 횟수

최선의 경우, 그러니까 이미 정렬된 원소 배열일 경우, 정렬 과정중 자리 교환이 한번도 일어나지 않을겁니다.

최악의 경우, 원소들을 비교할때마다 자리교환이 일어나므로, 자리교환 횟수 또한 비교횟수와 같아질 것입니다.

최선의 경우 교환 횟수 : 0

최악의 경우 교환 횟수 : n(n-1)/2

비교 횟수 와 자리 교환 횟수를 더하면 n²-n 이 되는데 시간 복잡도는 상수는 생략하고 최고차항만 생각합니다.

따라서 시간 복잡도는 빅 오 표기법으로 O(N²) 이 됩니다.

버블 정렬의 동영상 예시

출처 ( 유투브 동영상(클릭) )

감사합니다.

안녕하세요 게임개발자 놀이터입니다.

이번 포스팅에선 순차탐색에 대하여 정리하겠습니다.

순차 탐색 (Linear Search)

사실 순차 탐색, Linear Search라고 이름이 거창하지만, 한번쯤은 누구나 다 해봤을 탐색법입니다.

맨 앞에서부터 맨 끝까지 순서대로 탐색을 하는 알고리즘입니다.

시간 복잡도는 당연히 O(n)을 가지고있습니다.

종료 조건

배열에 길이에서 숫자를 발견하거나, 끝까지 발견하지 못할 경우 종료됩니다.

예제 코드

정말 간단했네요..

감사합니다.

안녕하세요. 게임개발자 놀이터입니다.

이번 포스팅에선 이진 탐색 알고리즘에 대해서 적어보려고 합니다.

이진 탐색 알고리즘 (Binary Search)

이진 탐색 알고리즘을 하기 위해선 데이터가 정렬되어있어야 합니다. 

정렬된 데이터가 아니면 적용이 불가능한 알고리즘이기 때문이죠.

코드를 살펴보기 전에 알고리즘에 진행 방식을 보겠습니다.

배열 { 1, 3, 4, 5, 7, 8, 10, 20, 60, 100 } 에서 5를 찾아보겠습니다.

첫번째 케이스

배열 시작 인덱스와 마지막 인덱스 값을 합하여 2로 나눕니다. 그 인덱스에 해당하는 값이 5인지 확인하고 아니라면 5보다 큰지, 작은지 확인합니다.

 (0 (시작 인덱스) + 9 (마지막 인덱스)) / 2 = 4.5 (나머지는 버립니다.) => 4

array[4]는 7 이므로 값이 같지 않으니 대 소 를 비교합니다.

array[4]가 찾고자 하는 값(5)보다 크니 4~마지막 인덱스 까진 탐색에서 제외합니다.

두번째 케이스

(0 (시작 인덱스) + 3 (마지막 인덱스)) / 2 = 1.5 => 1

array[1] 는 3 이므로 값이 같지 않으니 대 소 를 비교합니다.

array[1]가 찾고자 하는 값(5)보다 작으니 시작인덱스 ~ 1 까지 탐색에서 제외합니다.

세번째 케이스

(2 (시작 인덱스) + 3 (마지막 인덱스)) /2 = 2.5 => 2

array[2]는 4이므로 값이 같지 않으니 대 소 를 비교합니다.

array[2]가 찾고자 하는 값(5)보다 작으니 시작인덱스~2까지 탐색에서 제외합니다.

네번째 케이스

(3 (시작 인덱스)  + 3 (마지막 인덱스)) /2 = 3

array[3]은 5이므로 찾고자 하는 값과 같으니 반환하며 탐색을 종료합니다.

위처럼 절반 씩 줄어 들면서 값을 검색하니, 시간 복잡도는 O(Log N)을 가집니다.

값을 못찾았다면, 시작인덱스가 마지막인덱스 보다 커진 경우 탐색을 종료하며 실패를 반환합니다.

예시 코드

알고리즘의 종료 조건

위 코드처럼 시작인덱스(from)이 마지막인덱스(to)보다 커지면 종료합니다.

안녕하세요. 게임개발자 놀이터 입니다.

이번 포스팅에선 피보나치 수열에 대하여 정리 해보려고합니다.

피보나치 수열

피보나치 수열은 앞의 두 수 를 더해서 현재 위치의 수를 만드는 수열을 말합니다.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 ...

시작 두 수 인 0, 1을 제외하고 3번째 수부터 바로 전 수 와 전 전 수의 합계를 나타내면 됩니다.

0, 1, (0+1) , ((0+1) + 1) , (((0+1) + 1) +(0+1)) ...

간단한 알고리즘이라서 그런지 구현 방법은 여러가지가 있습니다.

먼저 재귀함수 호출을 이용한 피보나치 수열 구현 입니다.

1번째와 2번째의 값은 0과 1로 정해져있으니, 각각 0과 1을 반환하고, n의 전 값과, n의 전전 값을 더해서 리턴하는 형식을 가지고 있습니다.

간단하게 구현을 완료했지만, Algorithm 함수를 들어갈때마다 계속 n이 1인지, 2인지를 검사 하고 시작해야 하네요.

반복전인 2회 검사를 제거 하기 위해 이번엔 반복문으로 구현해봤습니다.

간단하게 재귀 함수를 호출하는 부분을 for문으로 변경해봤습니다.

current는 현재 숫자, beforevalue는 이전 숫자입니다.

다음 숫자는 현재 숫자 + 이전숫자 이므로, current와 beforevalue를 더해서 구합니다.

이것 외에 다른 방법은.. 성능상으로는 비슷하지만 코드상으로는 다른 '꼬리 재귀 함수'를 이용한 구현법이 있습니다.

구하려는 n번째 자리수를 이용하여 n을 한단계씩 줄여가며 before와 next를 더해가는겁니다. 

한 타임이 지나면

before는 next가 되며

next는 before + next가 됩니다.

그렇게 반복되며 꼬리재귀함수를 돌다가 n값이 0 이라면 현재 값(before)를 반환합니다.

꼬리 재귀 함수에 관해선 다른 포스팅에서 자세히 다루도록 하겠습니다.

감사합니다.

안녕하세요. 게임개발자 놀이터 입니다.

이번 포스팅에선 알고리즘 수행 시간을 분석하는 방법중 하나인 점근 표기법에 대해 포스팅 하려고 합니다.

대부분의 알고리즘은 입력된 크기가 작으면, 알고리즘의 효율과 상관 없이 빨리 끝납니다.

하지만 입력된 크기가 크면, 속도에 차이가 나게 됩니다. 그래서 알고리즘의 수행시간을 분석할 때는 항상 입력의 크기가 충분히 클때에 대해서 분석 합니다. 이를 점근적 분석 이라고 합니다.

대표적으로 5가지 표기법이 있습니다.

• 대문자 O 표기법 ( 빅 오 표기법 )
• 소문자 o 표기법 ( 리틀 오 표기법 )
• 대문가 오메가(Ω) 표기법 ( 오메가 표기법 )
• 소문자 오메가(ω) 표기법 ( 리틀 오메가 표기법 )
• 대문자 세타(Θ) 표기법 (세타 표기법 )

하나씩 적어 보도록 하겠습니다.

대문자 O 표기법 ( 빅 오 표기법 )

빅 오 표기법은 컴퓨터 공학에서 알고리즘의 복잡도 또는 성능을 표현하기 위해 사용됩니다.

빅 오 표기법은 특히 최악의 경우를 표현하며, 알고리즘의 실행 시간이나, 사용 메모리 (메모리, 또는 디스크) 공간을 표현 하기도 합니다.

O(1)

O(1) 은 알고리즘의 실행시간 (또는 공간)이 입력되는 데이터의 크기에 상관 없이 항상 같은경우를 의미합니다.

빅 오 표기들을 대소로 정리하면 다음과 같습니다.

O(1) < O(log N) < O(N) < O(N²) < O(2ⁿ)

소문자 o 표기법 ( 리틀 오 표기법 )

리틀 오 표기법은 빅 오 표기법 보다 좀 더 여유있는 상한을 표현할때 사용됩니다.

알고리즘의 복잡도 또는 성능을 표기할때는 자주 쓰이지 않는 표기법입니다.

어떤 알고리즘의 분석시간이 o(log N) 이라 한다면, 이는 해당 알고리즘의 소요시간이 입력크기 N에 대해 log N보다 완만하게 증가한다는것을 뜻합니다.

이해 하기 어려웠는데, log N처럼 증가하지 않지만, log N과 비슷하게 증가한다는 뜻입니다. 즉 O(log N)과 o(log N)은 같은 증가 속도가 될 순 없고, log N보다 완만하게 증가하는것이 분명할때 사용된답니다.

대문자 오메가(Ω) 표기법 ( 빅 오메가 표기법 )

빅 오메가 표기법은 빅 오 표기법과 마찬가지로 알고리즘의 복잡도 또는 성능을 표기할때 사용됩니다.

하지만, 빅 오 표기법은 최악의 경우 를 표시 했다면, 빅 오메가 표기법은 최고의 경우를 표현합니다.

손쉽게 말하면 f(N) = Ω(2N) 이라 한다면 f(N)은 적어도 2N에 비례하는 시간이 소요됨을 뜻합니다.

해당되는 알고리즘을 실행하는데 걸리는 최소한의 시간을 나타 내는 것입니다.

이는 맨 밑에있는 세타 표기법과 동시에 설명하는게 편하니, 밑에서 예제를 들겠습니다.

소문자 오메가(ω) 표기법 ( 리틀 오메가 표기법 )

리틀 오메가 표기법은 빅 오메가 표기법 보다 좀 더 여유있는 상한을 표현 할때 사용됩니다.

제가 위에 적은 리틀 오 표기법과 비슷하죠. 맞습니다.

어떤 알고리즘의 분석시간이 ω(log N) 이라 한다면, 이는 해당 알고리즘의 소요시간이 입력크기 N에 대해 log N보다 완만하게 증가한다는것을 뜻합니다.

이해 하기 어려웠는데, log N처럼 증가하지 않지만, log N과 비슷하게 증가한다는 뜻입니다. 즉 Ω(log N)과 ω(log N)은 같은 증가 속도가 될 순 없고, log N보다 완만하게 증가하는것이 분명할때 사용된답니다.

세타(Θ) 표기법 (세타 표기법 )

세타 표기법은 빅 오 표기법은 최악의 경우, 빅 오메가 표기법은 최고의 경우를 나타낸다면, 세타 표기법은 평균의 경우를 나타내는 표기법입니다.

빅 오 와 빅 오메가의 중간이라고 생각 하시면 편합니다.

중간이라는 표현은 좀 애매한데, 빅 오 와 빅 오메가의 교집합이라 생각하십니다. 그러니까

이 알고리즘은 아무리 좋아지거나 아무리 나빠지더라도 세타 범위 안에있다. 라는 뜻입니다.

점근적 표기법에 대해 어느정도 적어봤습니다.

적다 보니 빅 오 를 제외하고 나머지 4개 표기법에 대해서는 완벽하겐 모르겠네요.

앞으로 이 5개를 각각 1개 씩 나눠서 포스팅을 해야겠습니다.

감사합니다.

안녕하세요. 게임개발자 놀이터 입니다.

이번 포스팅에선 C++의 예약어중 하나인 inline에 대해 포스팅 하려고합니다.

C++ 책을 보다보면 꼭 나오는 예약어중 하나인데요.

쉽게 말하자면, 인라인 함수는 컴파일된 함수의 코드가 프로그램의 코드안에 직접 삽입이 되는겁니다.

즉, 컴파일러가 함수를 호출하는 과정이 사라져 버리는것이죠.

코드를 볼까요?

이렇게 선언한 코드를 컴파일 하게되면

위와 같이 바뀌게 됩니다. 어떤가요?

좀더 확실한 결과를 보기 위해 어셈블리 코드로 확인 해보겠습니다.

Visual C++에서 어셈블리 파일을 생성할떄 /Ob1 이라는 추가 명렁 옵션을 주셔야 어셈블리 코드가 정상적으로 출력됩니다.

(진짜 몰라서 엄청 고생했네요...)

먼저 인라인이 적용 되지 않은 어셈블 코드중 메인 함수를 보면

위와 같이 나오게 됩니다. 그후 Inline이 적용된 함수의 어셈블 코드를 보면

이렇게 나오게 됩니다.

13번째 줄을 보면 확연히 차이가 나는걸 보실수 있습니다.

음.. 보기 어렵군요?

함수를 좀더 보기 쉽게 바꿔보겠습니다.

소스코드

Inline이 적용하지 않은 어셈블리 코드

Inline이 적용된 어셈블리 코드

14 번의 코드를 보면 확 차이가 느껴지실껍니다.

가장 크게 어셈블리 코드상에서 call이 불리지 않게됩니다.

또 지금 코드상에선 push도 호출되고 있지 않네요.

일반 함수는 호출되는 과정을 보면, 우선 매개변수를 스택이 집어넣고, 함수를 호출합니다. 그후 함수내 리턴값을 위한 스택의 push, pop 도있고, 리턴후 스택 정리를 위한 pop이 있습니다.

이러한 함수 호출은 스택에 접급 하기 때문에 즉, 메모리에 접근 하기 때문에 속도가 저하 될 수 있습니다.

함수 호출에 대한 자세한 이야기는 다른 포스팅에서 다루겠습니다.

인라인을 쓰게되면 가장 먼저 속도와 메모리 면에서 효과가있습니다.

메모리는 위에 적은 것처럼 함수를 부르기 위해 스택에 넣었다 빼는 과정이 없어지기 때문이고, 그에따라 속도 면에서 더 빨라진답니다.

하지만 단점은 너무 반복해서 사용하게 될경우 어셈블리 코드가 길어진다는 것입니다. push와 call로 끝나는 함수가 여러번 호출되면서 여러번의 내용이 다 복사되서 어셈블리 코드로 적히게 되면 그 길이는 장난 아니겠죠?

결론

음.. 제 짧은 지식으로 내린 결론은 

함수 구문이 짧고, 호출이 적은 함수는 inline화 시키자는 겁니다. 크게 영향을 주지않는 함수 호출을 줄이자는거죠..!!

잘 모르는 분야라 댓글로 지적 해주시면 감사하겠습니다.