함수 오버로딩

두 수를 더하는 함수를 정수용과 실수용으로 따로 만들면 addInt, addDouble처럼 이름이 늘어나고, 쓰는 사람은 타입마다 다른 이름을 기억해야 합니다. C++에서는 같은 이름의 함수를 매개변수만 다르게 여러 개 정의할 수 있으며, 이것을 함수 오버로딩(function overloading)이라고 합니다.

이 글은 어떤 함수들이 서로 다른 오버로드가 될 수 있는지, 컴파일러가 호출마다 어느 함수를 고르는지, 고를 수 없을 때 생기는 모호한 호출을 봅니다. 끝으로 오버로드한 함수가 링커에서 구별되는 이름 맹글링을 간단히 소개합니다.

오버로드를 구별하는 기준

같은 이름의 함수들은 매개변수 타입의 목록이 달라야 서로 다른 오버로드가 됩니다. 매개변수의 개수가 다르거나, 같은 자리의 타입이 다르거나, 서로 다른 타입의 순서가 바뀌면 목록이 달라집니다.

위 그림의 아래쪽처럼 겉보기와 달리 같은 함수로 취급되는 경우도 있습니다. 매개변수 이름만 바꾼 것은 같은 함수이고, 반환 타입만 다른 것은 오버로드가 될 수 없어 컴파일 오류입니다. 호출문 add(1, 2)만 보고는 어느 반환 타입을 원하는지 알 수 없기 때문입니다.

int add(int a, int b) { return a + b; }
// double add(int a, int b) { return a + b; } // 컴파일 오류: 반환 타입만 다름

void read(int value);
void read(const int value); // 같은 함수의 선언

void scan(char text[]);
void scan(char* text);      // 같은 함수의 선언

값 매개변수의 맨 바깥 const는 함수 타입을 정할 때 빠지므로 read(int)와 read(const int)는 같은 함수입니다. 매개변수의 배열 타입은 1차원 배열에서 본 대로 포인터로 바뀌므로 scan(char[])과 scan(char*)도 같습니다. 반면 참조자에서 볼 int&와 const int&처럼 참조하는 대상의 타입이 다르면 서로 다른 오버로드가 됩니다.

오버로딩 예

정수 덧셈, 실수 덧셈, 세 정수의 덧셈, 문자열 이어 붙이기를 모두 add라는 이름으로 정의해 봅니다. 네 정의는 이름이 같고 매개변수의 개수나 타입만 다릅니다. 반환 타입도 서로 다르지만 반환 타입만 다른 두 함수는 오버로딩으로 인정되지 않으므로, 함수를 구별하는 것은 매개변수 쪽입니다.

#include <iostream>
#include <string>

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
std::string add(const std::string& a, const std::string& b) { return a + b; }

int main() {
    std::cout << add(5, 7) << '\n';
    std::cout << add(3.5, 2.25) << '\n';
    std::cout << add(1, 2, 3) << '\n';
    std::cout << add("Hello, ", "World") << '\n';
}

12
5.75
6
Hello, World

컴파일러는 호출마다 인자의 개수와 타입을 보고 알맞은 함수를 고릅니다. add(5, 7)은 두 int가 정확히 맞는 첫째 함수를, add(3.5, 2.25)는 둘째 함수를, 인자가 셋인 add(1, 2, 3)은 셋째 함수를 부릅니다. 이렇게 호출에 맞는 함수를 고르는 과정을 오버로드 해석(overload resolution)이라고 하며, 실행 중이 아니라 컴파일할 때 이루어집니다.

마지막 호출의 "Hello, "는 std::string이 아니라 char 배열입니다. 배열은 포인터로 바뀐 뒤 std::string의 생성자로 변환되어야 넷째 함수에 넘길 수 있는데, 이처럼 클래스가 정의한 변환을 사용자 정의 변환(user-defined conversion)이라고 합니다. 다른 세 함수에는 포인터를 넘길 방법이 없으므로 넷째 함수가 선택됩니다.

변환의 순위

여러 함수가 모두 호출 가능할 때, 컴파일러는 인자마다 필요한 변환의 순위를 비교합니다. 순위는 타입이 그대로 맞는 정확한 일치(exact match)가 가장 좋고, 그다음이 승격(promotion), 그다음 그 밖의 표준 변환(conversion), 마지막이 사용자 정의 변환입니다. 승격에는 형변환에서 본 작은 정수를 int로 넓히는 것과 함께 float를 double로 넓히는 것도 들어갑니다.

#include <iostream>

void print(int value) { std::cout << "int " << value << '\n'; }
void print(double value) { std::cout << "double " << value << '\n'; }

int main() {
    print(10);
    print(10.0);
    print(true);
    print('A');
    print(2.5f);
    // print(10L); // 컴파일 오류: 모호한 호출
}

int 10
double 10
int 1
int 65
double 2.5

true와 'A'는 int로의 승격이 double로의 변환보다 순위가 높아 print(int)를 고르고, 2.5f는 double로의 승격이 있어 print(double)을 고릅니다. 'A'가 65로 출력되는 것은 GCC가 쓰는 UTF-8에서 A의 값이 65이기 때문입니다. 반면 10L은 long에서 int로 가는 것과 double로 가는 것이 모두 같은 순위의 변환이어서, 어느 쪽도 더 낫지 않아 컴파일 오류가 납니다.

이 순위 때문에 생기는 함정도 있습니다. show(bool)과 show(const std::string&)가 함께 있으면 show("hello")는 문자열 버전이 아니라 bool 버전을 부릅니다. 포인터를 bool로 바꾸는 것은 표준 변환이고, std::string을 만드는 것은 그보다 순위가 낮은 사용자 정의 변환이기 때문입니다. 문자열을 받는 오버로드를 만들 때는 show(const char*)도 함께 두거나, 인자를 std::string으로 넘깁니다.

모호한 호출

인자가 여러 개이면 비교가 조금 더 엄격해집니다. 한 후보가 선택되려면 모든 인자에서 다른 후보보다 나쁘지 않고, 적어도 한 인자에서는 더 좋아야 합니다. 변환의 개수나 비용을 더해서 고르는 것이 아닙니다.

#include <iostream>

void choose(int, double) { std::cout << "A\n"; }
void choose(double, int) { std::cout << "B\n"; }

int main() {
    choose(1, 2.0);
    choose(1.0, 2);
    // choose(1, 2); // 컴파일 오류: 모호한 호출
}

A
B

choose(1, 2.0)에서 A는 두 인자가 모두 정확히 맞고 B는 둘 다 변환이 필요하므로 A가 선택되며, choose(1.0, 2)는 반대로 B입니다. 아래 그림은 주석으로 막아 둔 choose(1, 2)를 따라갑니다. 두 후보 모두 호출할 수는 있지만, A는 첫째 인자에서, B는 둘째 인자에서 더 좋아 우열이 엇갈립니다.

모든 인자에서 나쁘지 않은 유일한 후보가 없으므로 컴파일러는 둘 중 하나를 마음대로 고르지 않고 모호한 호출(ambiguous call)로 컴파일 오류를 냅니다. 호출 가능한 후보가 하나도 없을 때의 오류와는 다른 실패입니다. 이런 호출은 choose(1, static_cast<double>(2))처럼 인자의 타입을 밝히거나, 두 함수가 하는 일이 다르다면 이름을 나누어 해결합니다.

뒤의 기본 매개변수에서 볼 기본값도 모호함을 만들 수 있습니다. void f(int)와 void f(int, int = 0)이 함께 있으면 f(1)은 두 함수가 모두 같은 조건으로 호출 가능해 모호합니다. 오버로드를 늘릴 때는 같은 호출 모양을 받아들이는 함수가 둘 생기지 않는지 확인합니다.

main은 오버로딩할 수 없습니다

프로그램에는 전역 main 함수가 정확히 하나 있어야 하므로 main은 오버로딩할 수 없습니다. 컴파일러는 적어도 int main()과 int main(int argc, char* argv[]) 두 형태를 받아들여야 하며, 반환 타입은 언제나 int입니다. 두 형태 가운데 하나를 골라 정의합니다.

이름 맹글링

오버로드된 함수들은 소스에서 이름이 같지만, 링커는 이들을 서로 다른 함수로 구별해야 합니다. 그래서 컴파일러는 함수 이름에 매개변수 타입 정보를 덧붙인 심볼 이름을 만들며, 이것을 이름 맹글링(name mangling)이라고 합니다.

MSYS2의 GCC를 포함해 대부분의 GCC와 Clang이 따르는 Itanium C++ ABI에서는 add(int, int)가 _Z3addii, add(double, double)이 _Z3adddd처럼 표현됩니다. 반환 타입은 이 이름에 들어가지 않으며, 이것도 반환 타입만으로 오버로드를 구별할 수 없는 것과 맞아떨어집니다. MSVC는 다른 규칙을 쓰고 C++ 표준은 특정 형식을 요구하지 않으므로, 맹글링은 컴파일러가 오버로딩을 구현하는 방식으로 이해하면 됩니다.

더 깊이: 맹글링을 끄는 extern "C"와 맹글링 풀기

C로 작성한 라이브러리의 함수는 맹글링 없이 이름 그대로 목적 파일에 들어 있으므로, C++에서 그 함수를 부르려면 컴파일러가 맹글링한 이름을 찾지 않게 해야 합니다. extern "C" int open(const char* path, int flags, ...);처럼 선언하면 그 함수는 C 언어 링크(language linkage)를 가지며, 호출 규약과 이름을 만드는 방식이 C에 맞춰집니다. 반대로 C++로 정의한 함수에 extern "C"를 붙이면 C 코드에서 그 함수를 부를 수 있습니다. 대신 C 언어 링크를 가진 같은 이름의 함수 선언은 이름 공간이 달라도 같은 함수를 가리키므로, extern "C" 함수는 매개변수만 바꾼 오버로드를 둘 수 없습니다.

링커 오류나 디버거에 맹글링된 이름이 보이면 도구로 되돌려 읽을 수 있습니다. GNU binutils의 c++filt에 _Z3addii를 넘기면 add(int, int)로 바꾸어 보여 주며, 인자 없이 실행하면 표준 입력으로 받은 이름을 차례로 풀어 줍니다. MSVC의 이름은 형식이 달라 undname.exe로 풀며, Microsoft의 문서에 따르면 64비트 환경의 extern "C" 함수는 __vectorcall 호출 규약을 쓸 때만 이름이 꾸며집니다.

정리

• 같은 이름의 함수는 매개변수 타입의 목록이 달라야 오버로드가 되며, 반환 타입이나 매개변수 이름만 다른 것은 오버로드가 아닙니다.
• 값 매개변수의 맨 바깥 const와 배열 매개변수의 포인터 변환 때문에 겉보기와 달리 같은 함수가 되는 경우가 있습니다.
• 컴파일러는 인자마다 정확한 일치, 승격, 표준 변환, 사용자 정의 변환의 순서로 순위를 비교해 함수를 고릅니다.
• 문자열 리터럴은 std::string보다 bool로 먼저 변환되므로, bool과 문자열을 받는 오버로드를 함께 둘 때 주의합니다.
• 모든 인자에서 나쁘지 않은 유일한 후보가 없으면 모호한 호출로 컴파일 오류이며, 인자의 타입을 밝히거나 이름을 나누어 해결합니다.

연습 문제

1. 순위 비교

conversion_rank.cpp에서 print(short{3})과 print(3u)는 각각 어떻게 되나요?

2. 두 인자의 우열

choose.cpp에서 choose(1.0, 2.0)은 어떻게 되나요?

3. 서로 다른 오버로드인가

다음 네 쌍 가운데 서로 다른 두 오버로드가 되는 것은 무엇인가요? read(int)와 read(const int), scan(char[])과 scan(char*), f(int&)와 f(const int&), g(int)와 g(long)

다음 글 인라인 함수에서는 inline 키워드가 실제로 정하는 것과, 컴파일러의 인라인 확장이 서로 다른 이야기라는 점을 다룹니다.