1-4.함수의 확장
1.디폴트 인수
디폴트(Default)는 기본값, 내정치라는
뜻이며 별다른 지정이 없을 때 적용되는 값이다. 일일이 모든 것을 다 지정하기는 번거로워 기본값을 정해
두고 변화가 있는 부분만 밝히는 방식이 흔히 사용된다. 예를 들어 순댓국집에서 "여기 두 그릇요" 하면 순댓국 두 그릇을 의미한다. 순댓국집에 술국이나 해장국도 팔지만 디폴트는 순댓국이다.
컴퓨터 환경이나 프로그래밍 언어에도 디폴트는 흔히 사용된다. 수치
상수에 별다른 지정이 없으면 양수를 의미하므로 + 기호를 일일이 붙이지 않아도 된다. 즉 부호의 디폴트는 +이다. 물론
디폴트는 어디까지나 생략시의 기본값일 뿐이어서 -23 식으로 음수 부호를 명시적으로 붙이면 무시된다.
디폴트 인수는 함수의 선언부에 = 기호와 기본값이 정의되어 있는 인수이다. 호출부에 별다른 지정이 없으면 기본값을 알아서 적용한다. 물론 값을
명시적으로 전달하면 기본값은 무시된다.
|
defpara |
#include <stdio.h>
int GetSum(int from, int to, int step = 1, int base = 0);
int main()
{
printf("%d\n",
GetSum(1, 10));
printf("%d\n",
GetSum(1, 10, 2));
printf("%d\n",
GetSum(1, 10, 2, 10));
}
int GetSum(int from, int to, int step/* = 1*/, int base/* = 0*/)
{
int
sum = base;
for
(int i = from; i <= to; i += step) {
sum
+= i;
}
return
sum;
}
|
실행결과 |
55 25 35 |
GetSum 함수는 base에 from ~ to의 합계를 더하되 step 단위로 건너뛴다. 이 중 step은 1로, base는 0으로 무난한 기본값이 지정되어 있어 0부터 누적하며 1씩 증가한다.
GetSum(1, 10)으로 호출하면 1에서 10까지 1씩 증가하며 0에서부터 합계를 구하라는 뜻이다. 호출부에서 생략한 step과
base는 기본값인 1과 0이 적용된다.
누적합을 구할 때는 0부터 시작하고
1씩 증가하는게 보통이다. 웬만하면 무난한 값을 쓰지만 필요할 경우 인수값을 직접 지정할
수 있다. GetSum(1, 10, 2)는 step에 2를 지정하여 2씩 건너뛰며 합계를 구한다. step 인수를 명시적으로 지정했으므로 디폴트인 1은 무시된다. base도 적용하여 모든 인수를 다 지정하면 여기서부터 합계 누적을 시작한다.
함수의 인수가 많으면 변화를 줄 여지가 많아 활용성이 증가한다. 하지만
웬만하면 바꾸지 않는 무난한 값까지 인수로 받으면 호출할 때 일일이 전달해야 하니 불편하다. 디폴트
인수는 생략해도 상관없는 인수에 대해 기본값을 지정하여 활용성과 편의성을 동시에 만족시키는 기법이다. 개념은
간단하되 몇 가지 규칙만 주의하면 된다.
■ 디폴트 인수는 원형에 지정하며
정의부에는 지정하지 않는다. 두 군데 모두 지정되어 있고 기본값이 다를 경우의 모호함을 제거하기 위한
규칙이다. 정의부에는 인수 목록만 적거나 기본값을 주석 처리하여 기본값이 있다는 표시만 해 둔다.
■ 디폴트 인수는 오른쪽부터
순서대로 지정할 수 있으며 가운데 인수는 지정할 수 없다. 생략 가능한 인수를 뒤쪽에 배치해야 한다.
int GetSum(int from, int to = 10, int step = 1,
int base = 0); //
가능
int GetSum(int from, int to = 10, int step, int
base = 0); //
불가능
int GetSum(int from = 1, int to = 10, int step =
1, int base = 0); //
가능
int GetSum(int from = 1, int to, int step = 1, int
base = 0); //
불가능
뒤쪽의 to, step, base 셋 다 기본값을 줄 수는 있지만 step은 주지 않고 to에만 기본값을 지정할 수는 없다. 모든 인수에 기본값을 지정할 수 있지만 중간에 하나가 빠져서는 안된다.
■ 디폴트 인수를 가진 함수를
호출할 때도 뒤쪽의 인수만 생략할 수 있으며 중간의 한 인수를 생략할 수 없다.
GetSum(1, 10, , 100);
step은 1을 그대로
쓰고 base만 100으로 지정하고 싶다고 해서 중간에 인수
하나를 생략해서는 안된다. 더 뒤쪽의 인수를 지정하고 싶다면 앞쪽 인수도 값을 주어 GetSum(1, 10, 1, 100);식으로 호출한다. 만약 step을 생략하고 base를 지정할 일이 많다면 두 인수의 순서를
바꾸어야 한다.
함수를 만들 때는 요구 사항을 잘 파악하여 변화가 있을만한 부분을 인수로 받는다. 예를 들어 화면의 특정 좌표에 적을 출력하는 함수라면 좌표와 적의 종류를 인수로 받아들인다.
void OutEnemy(int x, int y, int Enemy);
요구 사항이 바뀌면 함수의 기능이 확장된다. 새로 추가된 적 캐릭터중
일부에 투명 처리가 들어간다고 해보자. bool Trans 인수를 추가하면 될 거 같지만 이렇게 되면
기존의 코드가 모두 영향을 받아 일일이 false 인수를 전달해야 하는 번거로움이 있다.
이미 작성되어 있는 기존 코드를 보호하려면 OutEnemyTrans 함수를
따로 만들 수 있지만 이렇게 되면 비슷한 코드가 중복되고 함수의 개수가 늘어나 역시 불편하다. 이럴
때 디폴트 인수가 요긴하게 사용된다.
void OutEnemy(int x, int y, int Enemy, bool Trans =
false);
기존의 OutEnemy 함수 호출문에 대해 Trans는 기본값 false가 적용되어 수정할 필요 없고 투명 처리가
필요한 캐릭터에 대해서만 Trans를 true로 전달하면
된다. 디폴트 인수를 사용하면 함수의 인터페이스가 유지되어 기존 코드를 보호하면서 기능을 확장할 수
있다.
2.함수 오버로딩
명칭은 중복되어서는 안되는 것이 원칙이며 같은 이름의 변수를 2개
선언할 수 없다. 그러나 함수는 예외적으로 인수열이 다르면 같은 이름으로 중복정의(overloading) 가능하다. 동작은 같되 인수의 형식이나 구현
방식이 약간 다른 함수는 이름이 같아도 무관하다.
|
overload |
#include <stdio.h>
int Add(int a, int b);
int Add(int a, int b, int c);
double Add(double a, double b);
int main()
{
printf("1
+ 2 = %d\n", Add(1, 2));
printf("3
+ 4 + 5 = %d\n", Add(3, 4, 5));
printf("1.414
+ 2.54 = %f\n", Add(1.414, 2.54));
}
int Add(int a, int b)
{
return
a + b;
}
int Add(int a, int b, int c)
{
return
a + b + c;
}
double Add(double a, double b)
{
return
a + b;
}
|
실행결과 |
1 + 2 = 3 3 + 4 + 5 = 12 1.414 + 2.54 = 3.954000 |
이 예제는 세 개의 Add 함수를 정의하는데 더한다는 동작은 같지만
인수의 타입이나 개수가 모두 다르다. 함수 이름은 같지만 인수열이 달라 모호하지 않으며 컴파일러는 호출부의
인수를 보고 호출할 함수를 정확하게 찾는다. 함수를 이름만으로 구분하는 C 에서는 동작이 같아도 함수명을 각각 다르게 작성해야 한다.
int AddInt2(int a, int b);
int AddInt3(int a, int b, int c);
double AddDouble2(double a, double b);
C 표준 함수 중에도 이런 예가 있는데 절대값을 구하는 함수가 인수
타입에 따라 abs, fabs, labs 세 가지나 있다. 논리적인
동작이 같은 함수를 타입에 따라 골라 써야 하니 불편하다. C++은 인수로 구분 가능하면 함수에 같은
이름을 줄 수 있고 호출부의 실인수 개수와 타입에 따라 적당한 함수를 골라주니 편리하다. 만약 실인수와
정확히 일치하는 함수가 없으면 산술 변환하여 함수를 찾는다.
short a = 1, b = 2, c;
c = Add(a, b);
두 개의 short값을 인수로 전달했는데 Add(short, short) 함수는 없지만 short가 int형으로 자동 변환할 수 있으므로 Add(int, int) 함수가
호출된다. 일치하는 함수도 없고 산술변환도 불가능하면 에러로 처리된다.
Add("one", "two")는 대응되는 함수가 없고 문자열을 정수나 실수로 바꿀 수 없으니
에러이다. Add(2.34, 5)처럼 산술 변환이 모호한 경우도 에러 처리된다.
이 경우는 2.34를 정수로 바꾸어
Add(int, int)를 호출할 수도 있고 5를 5.0으로
바꾸어 Add(double, double)를 호출할 수도 있다. 컴파일러는
모호한 상황에 대해서는 명확한 확인을 요구한다. Add((int)2.34, 5)나 Add(2.34, 5.0)으로 의사를 명확히 표현해야 한다. 다음
예제는 에러는 아니지만 역시 위험하다.
|
ptroverload |
#include <stdio.h>
void sub(int a) { printf("int : %d\n", a); }
void sub(int *a) { printf("pointer : %p\n", a); }
int main()
{
int i
= 1234, *pi = &i;
sub(i);
sub(pi);
sub(NULL);
}
|
실행결과 |
int : 1234 pointer : 004FF9C8 int : 0 |
정수형을 받는 sub 함수와 정수형 포인터를 받는 sub 함수가 중복 정의되어 있다. sub(i), sub(pi)에
대해 호출할 함수는 명확하지만 sub(NULL)이 애매하다. NULL은
정수 0으로 볼 수도 있고 널 포인터로도 볼 수 있는데 컴파일러는
NULL을 정수로 해석한다. sub(NULL)에 대해 포인터가 호출되기를 바랬다면 sub((int *)NULL)로 캐스팅해서 호출해야 한다.
오버로딩은 편리한 기능이지만 이처럼 타입이 애매한 경우 엉뚱한 함수가 호출되는 맹점이 있다. 그래서 리터럴에 대해서도 L, U, F 따위의 접미를 붙여 정확한
타입을 지정하는 문법이 제공되며 타입을 구분하지 못하는 #define보다 타입이 정확한 const 상수를 권장한다.
같은 이름으로 함수를 중복 정의할 수 있는 이유는 인수열을 보고 호출할 함수를 결정할 수 있기 때문이다. 호출부만으로 어떤 함수를 선택할지 명확히 구분되지 않는 모호한 경우는 오버로딩할 수 없다.
■ 형식 인수의 이름만 다른
경우는 안된다. 함수의 원형에서 형식 인수의 이름은 임시적인 명칭일 뿐 별 의미가 없고 함수를 구분하는
기준이 아니다.
int Add(int a, int b);
int Add(int c, int d);
이 두 함수는 호출부에서 볼 때 정수형 2개라는 점에서 같은 함수이다. Add(1, 2) 호출에 대해 어떤 함수를 호출할지 결정할 수 없다.
■ 인수의 논리적 의미가 다른
경우도 결국 형식 인수의 이름만 다른 경우와 같아 역시 구분할 수 없다. 학생을 학과와 출석 번호, 이름과 학번으로 각각 검색한다고 해 보자.
int FindStudent(char *depart, int depnum);
int FindStudent(char *name, int stnum);
인수의 의미가 완전히 다르지만 사람이 보기에만 그런 것이고 컴파일러가 보기에는 다 문자열 하나, 정수 하나일 뿐이라 똑같은 함수이다. 정 두 함수를 오버로딩시키고
싶다면 한쪽 함수의 인수 순서를 바꾸어 구분 가능하게 만들 수는 있다. 뒤쪽 함수를 다음과 같이 바꾸면
오버로딩 가능하다.
int FindStudent(int stnum, char *name);
학번을 앞에 두고 문자열을 뒤로 옮기면 두 함수를 구분할 수 있다. 그러나
인수의 순서가 헷갈리고 논리적으로도 바람직하지 않아 아예 다른 이름으로 함수를 따로 만드는 것이 좋다.
■ 리턴 타입만 다른 경우도
오버로딩의 대상이 아니다. 리턴값은 함수 호출단계에서 참고하는 것이 아니라 호출 후에 적용하는 것이기
때문에 어떤 함수를 호출할지 결정할 수 없다.
int func(int a, double b);
double func(int a, double b);
■ 레퍼런스와 일반 변수도
호출부의 모양이 같아 중복 정의할 수 없다. 둘 다 호출할 때는
Add(a, b)식이라 어떤 함수를 호출할지 모호하다.
int Add(int a, int b);
int Add(int &a, int &b)
■ 디폴트 인수에 의해 같아질
수 있는 경우도 모호하다. 다음 두 함수는 인수의 개수가 다르지만 c를
생략할 수 있어 Add(1, 2)가 Add(1, 2)를 의미하는지 Add(1, 2, 0)을 의미하는지 애매하다.
int Add(int a, int b);
int Add(int a, int b, int c = 0);
■ 사용자 정의형에 의해 결국
같은 타입인 경우도 오버로딩할 수 없다.
typedef int *PINT;
void sub(int *p);
void sub(PINT p);
PINT가 곧 int * 타입이므로
두 sub 함수는 인수의 타입이 같다. 마찬가지로 int *p를 받는 타입과 int p[]을 받는 타입도 둘 다 인수가
포인터여서 오버로딩할 수 없다.
규칙이 굉장히 많은 것 같지만 모두 인수의 개수와 타입이 같은 경우이다. 참고로 const 지정자는 오버로딩의 대상이어서 다음 두 함수는 오버로딩 가능하다.
int strlength(char *s);
int strlength(const char *s);
대상체가 상수인가 아닌가는 호출 시점에 분명히 판단할 수 있어 애매하지 않다.
단, 포인터가 상수인가 아닌가는 중요치 않아 오버로딩 대상이 아니다.
int strlength(char * const s);
이 경우는 내부에서 포인터를 변경할 수 있느냐 없느냐의 차이만 있는데 호출 시점에서 함수 내부의 동작까지 살펴볼
수는 없다. 그래서 이 함수는 char *를 취하는 함수와
같은 이름을 쓸 수 없다. 어차피 포인터 s는 지역 변수일
뿐이어서 함수가 포인터를 바꾸나 마나 실인수는 영향을 받지 않아 비상수 포인터를 받을 수 있다.
함수 오버로딩은 동일한 동작을 하는 함수를 같은 이름으로 정의함으로써 개발자의 기억력을 도와준다. 가장 적절한 사용예는 다음과 같다.
void DrawRect(int x1,int y1,int x2,int y2);
void DrawRect(POINT lefttop, POINT rightbottom);
void DrawRect(RECT *bound);
사각형을 그리는 함수를 세 가지 버전으로 정의했다. 좌상단과 우상단의 x, y 좌표를 직접 줄 수도 있고 두 개의 POINT 구조체를 전달할
수도 있다. 또는 두 점의 좌표를 가지는 RECT 구조체의
포인터로 전달해도 된다. 개발자는 타입에 따라 함수를 구분할 필요 없이 자신이 가장 구하기 쉬운 정보를
인수로 전달할 수 있으며 사각형을 그릴 때는 DrawRect 함수를 호출한다는 것만 기억하면 된다.
3.인라인 함수
함수는 반복된 동작을 하나의 틀로 정의해 두고 필요할 때마다 호출해 사용하는 것이다. 다음 예제의 randfunc 함수는 인수로 전달된 n보다 작은 난수 하나를 생성하여 돌려준다.
|
randfunc |
#include <stdio.h>
#include <stdlib.h>
int randfunc(int n)
{
return
rand() % n;
}
int main()
{
int i,
j, k;
i =
randfunc(10);
j =
randfunc(100);
k =
randfunc(50);
printf("난수 = %d,%d,%d\n", i, j, k);
}
|
실행결과 |
난수 = 1,67,34 |
반복을 제거한다는 면에서 구조적이며 사용하기도 편리하다. 그러나 내부적인
동작을 살펴보면 약간의 비효율이 있다.
함수를 호출할 때마다 분기가 일어나며 이 과정에서 내부적으로 스택 프레임이 생성되고 해제되는 복잡한 과정을 거친다. 호출 과정에서 비용이 발생하는 셈이다. 함수가 거대하고 많은 일을
한다면 이 비용이 덜 부담스럽지만 난수 하나를 생성하는 간단한 작업을 하는데 너무 오랜 시간이 걸린다.
이럴 때는 함수로 분기하지 말고 호출 부에 해당 코드를 직접 삽입하는 것이 더 빠르다. 이런 식으로 동작하는 함수를 인라인(inline) 함수라고 한다. 분기하지 않고 함수 본체의 코드를 바로 새겨 넣어 버림으로써 호출의 부담을 제거하는 기법이다. 함수를 인라인으로 만들려면 함수 선언문 앞에 inline 키워드를
붙인다.
inline int randfunc(int n)
{
return
rand() % n;
}
인라인으로 지정된 함수는 호출문에 함수 본체를 삽입한다. randfunc(10)
호출문이 rand() % 10 코드로 대체되어 버린다. 함수
실행 방법이 바뀌었을 뿐 코드가 바뀐 것은 아니므로 결과는 같다.
함수로 분기하지 않아 실행속도는 빨라지지만 본체가 매번 삽입되어 실행 파일은 더 커진다. 즉 인라인은 속도에 유리하고 크기에 불리한 방법이다. 본체가 짧고
속도가 중요한 함수를 인라인으로 선언하면 유리하다. 반면 큰 함수는 호출 시간이 실행 시간에 비해 상대적으로
짧기 때문에 인라인으로 만들어도 별 이득이 없으며 실행 파일만 비대해져 불리하다.
개발자는 인라인으로 만들고 싶은 함수 앞에 inline 키워드를 붙여
의사를 밝힐 뿐이며 이 함수가 실제 인라인이 될 것인가 아닌가는 컴파일러가 결정한다. 아무리 개발자의
지정이 있더라도 다음의 경우에는 인라인이 될 수 없다.
■ 재귀 호출 함수는 스택을 기반으로 하므로 실제 호출이 일어나야 정상 동작한다. 이
경우는 인라인 지정을 무시하고 일반 함수로 컴파일한다. 재귀 호출 함수가 인라인이 되면 크기가 무한대다.
■ 함수 포인터로 가리키는 함수는 인라인이 될 수 없다. 실제 본체를 가져야 번지가
할당되는데 인라인은 번지를 가지지 않는다.
■ 함수가 너무 길면 득보다 실이 많아 일반 함수로 컴파일한다.
반면, 인라인 지정을 하지 않아도 자동으로 인라인이 되는 경우도 있다. 클래스 선언문에 작성된 함수는 항상 인라인이 된다. 인라인 함수와
일반 함수는 호출 속도와 크기의 차이만 있을 뿐 동작 자체에 변화는 없어 컴파일러가 재량껏 인라인 여부를 결정한다.
인라인 함수는 그 자리에 코드가 삽입된다는 면에서 매크로 함수와 유사하다. 실제로 randfunc 함수와 똑같이 동작하는 매크로 함수를 만들 수 있으며 이 책에서 실습용으로 사용하는 cursor.h 헤더파일에도 작성되어 있다.
#define random(n) (rand()%(n))
매크로 함수도 크기에 불리하고 속도에 유리하다는 특성이 같아 이 둘은 서로 대체 가능한 관계이다. 그러나 인라인 함수는 기계적으로 동작하는 매크로 함수에 비해 다음과 같은 이점이 있다.
■ 타입을 인식하므로 민감한 타입 문제가 없고 산술 변환도 잘 처리된다.
■ 어쨌든 함수의 형태를 띠므로 지역 변수를 사용할 수 있다.
■ 매크로는 괄호를 잘 싸지 않으면 부작용이 있지만 인라인 함수는 컴파일러가 처리하므로 안전하다.
무식하게 동작하는 매크로 함수에 비해 컴파일러가 처리하는 인라인 함수가 한 수 위이며 그래서 C++은 매크로 함수보다 인라인 함수를 권장한다. 그러나 매크로 함수도
나름의 이점이 있어 기존의 잘 동작하던 것까지 인라인으로 만들 필요는 없다. 다음 함수는 인라인으로
만들 수 없다.
#define ARSIZE(ar) (sizeof(ar)/sizeof(ar[0]))
배열의 크기를 계산하는 매크로인데 배열 자체를 함수로 넘길 방법이 없기 때문에 인라인으로는 이 동작을 구현할
수 없다. 이 경우는 매크로같은 단순 무식한 방법이 더 유용하다.
셀프 테스트
1-1
#include <stdio.h>
int main()
{
double
*ar;
ar =
new double[100];
ar[50]
= 3.14;
printf("%f\n",
ar[50]);
delete[]
ar;
}
1-2
#include <iostream>
using namespace std;
int main()
{
int
left, right;
cout
<< "좌변을 입력하시오 : ";
cin
>> left;
cout
<< "우변을 입력하시오 : ";
cin
>> right;
cout
<< "두 정수의 합은 " << left + right
<< "입니다." << endl;
}
1-3
#include <iostream>
using namespace std;
void getposition(int &x, int &y)
{
cout
<< "x 좌표를 입력하시오 : ";
cin
>> x;
cout
<< "y 좌표를 입력하시오 : ";
cin
>> y;
}
int main()
{
int x,
y;
getposition(x,
y);
cout
<< "입력한 좌표는 (" << x <<
", " << y << ")입니다."
<< endl;
}
호출원에서는 변수를 먼저 선언하고 이 변수에 대한 레퍼런스를 인수로 전달한다.
레퍼런스 인수를 통해 값을 리턴할 수 있으므로 여러 개의 값을 채워줄 수 있다.
연습 문제
1. C++에서 확장된 문법이 아닌 것은?
① 한줄 주석을 달 때는 // 기호를 사용한다.
② 함수 중간에도 변수를 선언할 수 있다.
③ { } 블록의 선두에 변수를 선언할 수 있다.
④ for문의 초기식에 제어 변수를 선언할 수 있다.
2.다음 중 객체 지향 프로그래밍의 특징이 아닌 것은
① 섬세한 제어 ② 캡슐화 ③ 다형성 ④ 상속
3.객체 지향 프로그래밍에 대한 설명 중 틀린 것은
① 부품을 먼저 만들고 조립하는 Bottom Up 방식이다.
② C++ 언어의 고유한 기능이다.
③ 문제를 푸는 사고 방식이다.
④ 소프트웨어 위기를 해결하기 위해 대두되었다.
4. new 연산자에 대한 설명으로 잘못된 것은?
① 별도의 헤더 파일을 포함할 필요가 없다.
② 임의 타입에 대해 메모리를 할당할 수 있다.
③ 할당과 동시에 초깃값을 지정할 수 있다.
④ 할당한 메모리의 크기를 바꾸어 재할당할 수 있다.
5. 레퍼런스에 대한 설명을 옳지 않은 것은?
① 실행중에 대상체를 바꿀 때는 = 연산자를 사용한다.
② 좌변값만 가리킬 수 있다.
③ 대상체와 타입이 완전히 일치해야 한다.
④ 대상체에 적용되는 모든 연산을 다 할 수 있다.
6.다음 중 선언 가능한 형식은 무엇인가?
① 레퍼런스에 대한 레퍼런스
② 포인터에 대한 레퍼런스
③ 레퍼런스에 대한 포인터
④ 레퍼런스 배열
7.레퍼런스의 내부 구조에 대한 설명으로 틀린 것은?
① 포인터의 변형이며 레퍼런스는 내부적으로 포인터로 선언된다.
② 레퍼런스를 참조하는 모든 문장에 암시적으로 * 연산자가 적용된다.
③ 레퍼런스의 대상체에 대해 암시적으로 &연산자가 적용된다.
④ 포인터가 가리킬 수 있는 모든 변수, 상수에 대한 레퍼런스를 선언할
수 있다.
8.디폴트 인수를 선언 및 사용하는 규칙으로 옳지 않은 것은?
① 오른쪽부터 순서대로 디폴트 인수를 지정한다.
② 호출할 때도 오른쪽부터 순서대로 생략할 수 있다.
③ 선언부와 정의부에 모두 디폴트값을 밝혀야 한다.
④ 가운데 인수를 생략하고 싶다면 순서를 바꾸어야 한다.
9.다음중 같은 이름의 함수를 정의할 수 있는 경우는?
① 형식 인수의 이름이 다른 경우
② 형식 인수의 논리적 의미가 다른 경우
③ 형식 인수의 개수가 다른 경우
④ 리턴 타입이 다른 경우
10.다음 두 함수는 오버로딩할 수 없다. 이유는 무엇인가?
int increase(int value);
void increase(int &value);
11. 다음 중 인라인 함수로 적합한 것은?
① 본체가 짧고 자주 호출되는 함수
② 재귀 호출 함수
③ 함수 포인터로 간접 호출하는 함수
④ 수십줄이 넘는 거대한 함수