C++ 함수 오버로딩 | "Function Overloading" 가이드
이 글의 핵심
C++ 함수 오버로딩에 대해 정리한 개발 블로그 글입니다. int add(int a, int b) { return a + b; }
함수 오버로딩이란?
같은 이름, 다른 매개변수를 가진 여러 함수
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;
}
int main() {
std::cout << add(1, 2) << std::endl; // 3 (int 버전)
std::cout << add(1.5, 2.5) << std::endl; // 4.0 (double 버전)
std::cout << add(1, 2, 3) << std::endl; // 6 (3개 인자 버전)
}오버로딩 규칙
// ✅ 매개변수 개수 다름
void func(int x);
void func(int x, int y);
// ✅ 매개변수 타입 다름
void func(int x);
void func(double x);
// ✅ const 다름
void func(int* ptr);
void func(const int* ptr);
// ❌ 반환 타입만 다름 (오버로딩 불가)
int func(int x);
// double func(int x); // 에러실전 예시
예시 1: 출력 함수
#include <iostream>
#include <vector>
void print(int x) {
std::cout << "int: " << x << std::endl;
}
void print(double x) {
std::cout << "double: " << x << std::endl;
}
void print(const std::string& s) {
std::cout << "string: " << s << std::endl;
}
void print(const std::vector<int>& vec) {
std::cout << "vector: ";
for (int x : vec) {
std::cout << x << " ";
}
std::cout << std::endl;
}
int main() {
print(42);
print(3.14);
print(std::string("Hello"));
print(std::vector<int>{1, 2, 3});
}예시 2: 최대값 함수
int max(int a, int b) {
return a > b ? a : b;
}
double max(double a, double b) {
return a > b ? a : b;
}
int max(int a, int b, int c) {
return max(max(a, b), c);
}
template<typename T>
T max(const std::vector<T>& vec) {
if (vec.empty()) {
throw std::invalid_argument("빈 벡터");
}
T maxVal = vec[0];
for (const auto& val : vec) {
if (val > maxVal) {
maxVal = val;
}
}
return maxVal;
}
int main() {
std::cout << max(10, 20) << std::endl;
std::cout << max(1.5, 2.5) << std::endl;
std::cout << max(1, 2, 3) << std::endl;
std::vector<int> nums = {5, 2, 8, 1, 9};
std::cout << max(nums) << std::endl;
}예시 3: 생성자 오버로딩
class String {
private:
char* data;
size_t length;
public:
// 기본 생성자
String() : data(nullptr), length(0) {}
// C 문자열
String(const char* str) {
length = strlen(str);
data = new char[length + 1];
strcpy(data, str);
}
// 반복 문자
String(char c, size_t count) {
length = count;
data = new char[length + 1];
memset(data, c, length);
data[length] = '\0';
}
// 복사 생성자
String(const String& other) {
length = other.length;
data = new char[length + 1];
strcpy(data, other.data);
}
~String() {
delete[] data;
}
};
int main() {
String s1; // 기본 생성자
String s2("Hello"); // C 문자열
String s3('*', 10); // 반복 문자
String s4(s2); // 복사 생성자
}예시 4: 검색 함수
#include <vector>
#include <string>
// 정수 검색
int find(const std::vector<int>& vec, int target) {
for (size_t i = 0; i < vec.size(); i++) {
if (vec[i] == target) {
return i;
}
}
return -1;
}
// 문자열 검색
int find(const std::vector<std::string>& vec, const std::string& target) {
for (size_t i = 0; i < vec.size(); i++) {
if (vec[i] == target) {
return i;
}
}
return -1;
}
// 조건 검색
template<typename T, typename Predicate>
int find(const std::vector<T>& vec, Predicate pred) {
for (size_t i = 0; i < vec.size(); i++) {
if (pred(vec[i])) {
return i;
}
}
return -1;
}
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
std::cout << find(numbers, 3) << std::endl; // 2
std::vector<std::string> words = {"apple", "banana", "cherry"};
std::cout << find(words, std::string("banana")) << std::endl; // 1
std::cout << find(numbers, { return x > 3; }) << std::endl; // 3
}const 오버로딩
class Array {
private:
int data[10];
public:
// non-const 버전
int& operator {
return data[index];
}
// const 버전
const int& operator const {
return data[index];
}
};
int main() {
Array arr;
arr[0] = 10; // non-const 버전
const Array& constArr = arr;
int x = constArr[0]; // const 버전
}자주 발생하는 문제
문제 1: 모호한 호출
void func(int x) {
std::cout << "int" << std::endl;
}
void func(double x) {
std::cout << "double" << std::endl;
}
int main() {
func(10); // int
func(3.14); // double
// func(10.0f); // 모호함! float -> int? double?
func(static_cast<int>(10.0f)); // int
func(static_cast<double>(10.0f)); // double
}문제 2: 기본 인자와 충돌
// ❌ 모호함
void func(int x) {
std::cout << "1개 인자" << std::endl;
}
void func(int x, int y = 0) {
std::cout << "2개 인자" << std::endl;
}
int main() {
// func(10); // 에러: 모호함
func(10, 20); // OK
}
// ✅ 다른 이름 사용
void func1(int x);
void func2(int x, int y = 0);문제 3: 포인터 vs 배열
void func(int* ptr) {
std::cout << "포인터" << std::endl;
}
void func(int arr[]) {
std::cout << "배열" << std::endl;
}
// 에러: 같은 시그니처 (배열은 포인터로 decay)문제 4: 반환 타입
// ❌ 반환 타입만 다름 (오버로딩 불가)
int getValue() {
return 42;
}
// double getValue() { // 에러
// return 3.14;
// }
// ✅ 다른 이름 사용
int getIntValue() {
return 42;
}
double getDoubleValue() {
return 3.14;
}오버로드 해결 규칙
void func(int x) { std::cout << "int" << std::endl; }
void func(double x) { std::cout << "double" << std::endl; }
void func(const std::string& s) { std::cout << "string" << std::endl; }
int main() {
func(10); // 정확히 일치: int
func(3.14); // 정확히 일치: double
func("hello"); // 변환: const char* -> string
char c = 'A';
func(c); // 승격: char -> int
short s = 10;
func(s); // 승격: short -> int
}FAQ
Q1: 함수 오버로딩은 언제 사용?
A:
- 같은 동작, 다른 타입
- 매개변수 개수 다름
- 편의 함수
Q2: 오버로딩 vs 템플릿?
A:
- 오버로딩: 타입별 다른 구현
- 템플릿: 같은 로직, 제네릭
Q3: 성능 영향?
A: 없음. 컴파일 타임에 해결.
Q4: 반환 타입으로 오버로딩?
A: 불가. 매개변수로만 구분.
Q5: 모호한 호출은?
A: 명시적 캐스팅 또는 다른 이름 사용.
Q6: 함수 오버로딩 학습 리소스는?
A:
- “Effective C++”
- cppreference.com
- “C++ Primer”
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ 기본 인자 | “Default Arguments” 가이드
- C++ 함수 | “처음 배우는” 함수 만들기 완벽 가이드 [예제 10개]
- C++ Name Mangling | “이름 맹글링” 가이드
관련 글
- C++ 이름 은닉 |