[C++] Operator Overloading & Class Keywords

📚 C++ 함수/연산자 오버로딩과 클래스 주요 키워드

🔸 Function/Operator Overloading

Function Overloading (함수 오버로딩)

• 같은 이름의 함수를 여러 개 정의
• 매개변수의 타입이나 개수가 달라야 함
• Name Mangling: 컴파일러가 함수 이름에 타입 정보를 추가하여 구분
• Static Polymorphism: 컴파일 타임에 어떤 함수를 호출할지 결정

void print(int x) { std::cout << "int: " << x << std::endl; }
void print(double x) { std::cout << "double: " << x << std::endl; }
void print(std::string x) { std::cout << "string: " << x << std::endl; }

int main()
{
    print(10);        // print(int) 호출
    print(3.14);      // print(double) 호출
    print("hello");   // print(std::string) 호출
    return 0;
}

Operator Overloading (연산자 오버로딩)

struct ComplexNum
{
    double real;
    double imag;
    
    ComplexNum(double r, double i) : real{r}, imag{i} {}
    
    void print() const
    {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

// + 연산자 오버로딩 (전역 함수로 구현)
ComplexNum operator+(const ComplexNum& lhs, const ComplexNum& rhs)
{
    return ComplexNum{lhs.real + rhs.real, lhs.imag + rhs.imag};
}

int main()
{
    ComplexNum c1{1, 1};
    ComplexNum c2{1, 2};
    
    ComplexNum c3 = c1 + c2;  // operator+(c1, c2) 호출
    c3.print();  // 2 + 3i
    
    return 0;
}

멤버 함수 vs 전역 함수

// 멤버 함수로 구현
struct ComplexNum
{
    ComplexNum operator+(const ComplexNum& rhs) const
    {
        return ComplexNum{real + rhs.real, imag + rhs.imag};
    }
};
// c1 + c2 → c1.operator+(c2)

// 전역 함수로 구현
ComplexNum operator+(const ComplexNum& lhs, const ComplexNum& rhs)
{
    return ComplexNum{lhs.real + rhs.real, lhs.imag + rhs.imag};
}
// c1 + c2 → operator+(c1, c2)

전역 함수가 필요한 경우:

• 왼쪽 피연산자가 다른 타입일 때 (예: 2 * complex)
• 대칭적인 연산을 구현할 때

private 멤버 접근 문제:

• 전역 함수는 클래스의 private 멤버에 접근할 수 없음
• friend 키워드로 접근을 허용할 수 있지만, 캡슐화를 깨뜨리므로 권장하지 않음
• 대신 public getter 함수를 제공하거나 멤버를 public으로 만드는 것이 좋음 (간단한 구조체의 경우)

// ❌ friend 사용 (캡슐화 위반)
class ComplexNum {
    double real;
    double imag;
    friend ComplexNum operator+(const ComplexNum&, const ComplexNum&);
};

// ✅ public 멤버 또는 getter 사용
struct ComplexNum {
    double real;  // 간단한 데이터 구조는 public으로
    double imag;
};
// 또는
class ComplexNum {
    double real;
    double imag;
public:
    double getReal() const { return real; }
    double getImag() const { return imag; }
};

🔸 Class 관련 키워드

const (멤버 함수)

class Cat
{
    std::string mName;
    int mAge;
    
public:
    // const 멤버 함수: 객체의 상태를 변경하지 않음
    void print() const
    {
        std::cout << mName << " " << mAge << std::endl;
        // mAge = 10;  // ❌ 컴파일 에러!
    }
    
    std::string getName() const { return mName; }  // ✅ OK
    
    void setAge(int age) { mAge = age; }  // non-const 함수
};

int main()
{
    const Cat kitty{"kitty", 1};
    kitty.print();      // ✅ OK (const 함수)
    kitty.getName();    // ✅ OK (const 함수)
    kitty.setAge(2);    // ❌ 컴파일 에러! (non-const 함수)
    return 0;
}

mutable (가변 멤버 변수)

• const 멤버 함수 내에서도 수정 가능한 멤버 변수
• 주로 캐싱, 통계, 디버깅 정보 등에 사용
• 남용하면 const의 의미가 퇴색되므로 신중하게 사용

class Cat
{
    std::string mName;
    mutable int mCallCount;  // mutable 멤버
    
public:
    Cat(std::string name) : mName{std::move(name)}, mCallCount{0} {}
    
    std::string getName() const
    {
        mCallCount++;  // ✅ const 함수지만 수정 가능
        return mName;
    }
    
    int getCallCount() const { return mCallCount; }
};

int main()
{
    const Cat kitty{"kitty"};
    kitty.getName();
    kitty.getName();
    std::cout << kitty.getCallCount();  // 2
    return 0;
}

explicit (명시적 변환)

• 암묵적 타입 변환(Implicit Conversion)을 방지
• 주로 단일 매개변수 생성자에 사용

Implicit Conversion 문제 상황

class Cat
{
    int mAge;
    
public:
    Cat(int age) : mAge{age} {}  // 단일 매개변수 생성자
};

void func(Cat cat) { /* ... */ }

int main()
{
    Cat kitty = 3;      // ✅ Cat(3)으로 암묵적 변환
    func(5);            // ✅ Cat(5)로 암묵적 변환
    // 의도하지 않은 변환이 발생할 수 있음!
    return 0;
}

explicit으로 해결

class Cat
{
    int mAge;
    
public:
    explicit Cat(int age) : mAge{age} {}  // explicit 키워드
};

int main()
{
    Cat kitty = 3;      // ❌ 컴파일 에러!
    Cat kitty{3};       // ✅ OK (명시적 생성)
    Cat kitty(3);       // ✅ OK (명시적 생성)
    
    func(5);            // ❌ 컴파일 에러!
    func(Cat{5});       // ✅ OK (명시적 생성)
    
    return 0;
}

explicit 사용 가이드라인

• 단일 매개변수 생성자는 거의 항상 explicit을 붙이는 것이 좋음
• 의도적인 암묵적 변환이 필요한 경우만 생략 (예: wrapper 클래스)
• C++11부터는 여러 매개변수 생성자에도 사용 가능

class Vector
{
public:
    explicit Vector(int size) {}           // ✅ explicit 권장
    Vector(int x, int y, int z) {}         // 여러 매개변수는 선택적
    explicit Vector(std::vector<int> v) {} // ✅ explicit 권장
};

---

<참고 자료>

코드없는 프로그래밍
C++ Operator Overloading