C++ 연산자 오버로딩(Operator Overloading)

연산자 오버로딩(Operator Overloading)이란?

 

연산자 오버로딩은 말 그대로 연산자(operator)의 동작을 새로 정의(재정의)하는 것이다.

예를 들어, + 연산자는 숫자끼리 더할 때 쓰는 것인데 이 + 연산자를 우리가 만든 클래스에서도 사용할 수 있게끔 동작을 새로 정의하는 것이다. 새로운 타입(클래스나 구조체)을 만들 때, 그 타입에 대해 +, -, *, / 같은 연산을 자연스럽게 사용하고 싶을 때가 있다. ( ex 두 개의 복소수를 더할 때 c1 + c2처럼 간단하게 쓰고 싶을 때) 그런데, 기본적으로는 클래스에 대해 + 같은 연산이 정의되어 있지 않아서 쓸 수 없다. 따라서 직접 + 연산이 어떻게 작동할지를 정의해 주는 것을 연산자 오버로딩이라고 한다.

연산자 오버로딩을 사용하면 연산자를 써서 조작할 수 있게 되므로 코드를 더 직관적이고 간결하게 작성할 수 있다.

 

 

다음과 같은 연산자들은 오버로드 될 수 있다.

 

::, ., *, ?:, sizeof, typeid 는 연산자 오버로드 될 수 없다.

 

 

예제)

#include <iostream>
using namespace std;

class Complex {
    double re, im;

public:
    Complex(double re = 0.0, double im = 0.0) {
        this->re = re;
        this->im = im;
    }

    void operator += (const Complex& c) {  // 연산자 오버로딩을 사용하여 += 연산자를 정의한 부분
        re += c.re;  //  c 객체의 실수 부분을 this 객체의 실수 부분에 더해주는 코드
        im += c.im;  //  c 객체의 허수 부분을 this 객체의 허수 부분에 더해주는 코드
    }

    void print() const {
        cout << re << " + " << im << "i" << endl;
    }
};

int main() {
    Complex c1, c2(2, 3);
    c1.print();           // 0 + 0i

    c1 += c2;             // c1.operator+=(c2) c1 객체의 re와 im 값에 각각 c2 객체의 re와 im 값을 더함
    c1.print();           // 2 + 3i

    return 0;
}

 

operator +=는 C++에서 += 연산자를 오버로딩하여 사용하는 함수의 시그니처.

 

+= 연산자는 기본적으로 내장된 자료형(예: int, double)에 대해 정의되어 있지만, 사용자 정의 클래스인 Complex에 대해 이 연산자를 사용할 수 있도록 오버로딩한 것이다.

 

const Complex& c는 참조를 통해 전달된 Complex 타입의 객체를 의미한다.

const 키워드는 이 함수 내부에서 c 객체의 값을 변경할 수 없도록 보장한다.

 

 

예제)

class Complex {
private:
    double re, im;  //re는 실수, im는 허수 부분이다

public:
    Complex(double r = 0, double i = 0) : re(r), im(i) {}

    // == 연산자 오버로딩
    bool operator==(const Complex& other) const {
        // 실수 부분과 허수 부분이 모두 같다면 true, 그렇지 않으면 false를 반환함.
        return (re == other.re) && (im == other.im);
    }
};

 

bool operator==(const Complex& other) const는 == 연산자가 두 개의 Complex 객체를 비교할 때 사용된다.

 

비교는 객체의 실수 부분(re)과 허수 부분(im)이 모두 같은지 확인하는 방식으로 이루어진다.

 

 

 

 

Non-Member Operators (비멤버 연산자) 의 연산자 오버로딩

 

클래스의 멤버 함수가 아닌, 클래스 외부에서 정의된 연산자 함수에서도 연산자 오버로딩을 할 수 있다. 일반적으로 연산자 오버로딩은 클래스 내부에서 멤버 함수로 정의되지만, 특정 경우에는 클래스 외부에서 이 연산자를 오버로딩해야 할 필요가 생길 수 있다. 이런 경우에 friend 함수나 비멤버 함수(non-member function)를 사용하여 연산자 오버로딩을 정의할 수 있다.

#include <iostream>
using namespace std;

class Complex {
private:
    double re, im;

public:
    Complex(double r = 0, double i = 0) : re(r), im(i) {}

    // friend 함수를 사용하여 두 개의 Complex 객체를 더하는 함수 선언
    friend Complex addComplex(const Complex& c1, const Complex& c2);

    void print() const {
        cout << re << " + " << im << "i" << endl;
    }
};

// friend 함수 정의
Complex addComplex(const Complex& c1, const Complex& c2) {
    return Complex(c1.re + c2.re, c1.im + c2.im);
}

int main() {
    Complex c1(1, 2);  // 1 + 2i
    Complex c2(3, 4);  // 3 + 4i

    Complex result = addComplex(c1, c2);  // friend 함수 호출

    cout << "두 복소수의 합: ";
    result.print();  // 결과 출력

    return 0;
}

 

이 예제에서 addComplex 함수는 Complex 클래스의 멤버가 아니지만, re와 im에 접근하여 두 객체를 더하는 작업을 수행할 수 있다.

 

 

C++ 클래스(Class)와 friend 함수/클래스, this 포인터

 

• friend 함수는 클래스의 멤버 함수가 아니지만, 클래스 내부의 비공개 멤버에 접근할 수 있다.
• friend 함수를 사용하면, 클래스 외부에서 정의된 함수도 마치 클래스 멤버 함수처럼 클래스 내부의 데이터에 접근할 수 있게 된다.

 

 

 

 

혼합형 연산 (Mixed-mode Arithmetic) 에서의 연산자 오버로딩

 

Mixed-Mode Arithmetic(혼합형 연산)란 프로그래밍에서 서로 다른 데이터 타입 간의 연산을 의미한다. 예를 들어, 하나의 피연산자가 int형이고 다른 피연산자가 double형일 때 이들 사이에서 발생하는 연산을 혼합형 연산이라고 한다.

 

C++에서는 두 개의 다른 데이터 타입을 연산할 때 묵시적으로, ***자동으로 형 변환이 일어나며***, 이러한 연산을 지원할 수 있도록 연산자를 오버로딩할 수 있다. 

 

Mixed-Mode Arithmetic은 C++에서 매우 유용한 기능이다. 연산자 오버로딩을 통해 기본 자료형과 사용자 정의 클래스 간의 연산을 가능하게 하여 더욱 자연스러운 코드 작성을 돕는다. 이로 인해 코드의 가독성과 유지보수성이 향상되며, 사용자가 정의한 데이터 타입을 쉽게 다룰 수 있게 된다.

 

 

<C++ 연산자 오버로딩의 자동 형변환 : 묵시적 형변환 장점>

1. 유연성: 사용자가 정의한 Complex 타입과 기본 자료형인 double을 자연스럽게 연산할 수 있어 코드를 더 유연하고 직관적으로 만들 수 있습니다.
2. 사용 편의성: Mixed-Mode Arithmetic을 사용하면 복소수 연산이 더욱 자연스러워집니다. 예를 들어, c1 + 10 또는 10 + c1 같은 연산이 가능해집니다.
3. 형 변환의 제어: 자동 형 변환이 이루어지는 상황에서 오버로딩된 연산자는 어떤 연산이 이루어질지 명확하게 정의하므로 예기치 않은 결과를 방지할 수 있습니다.

 

#include <iostream>
using namespace std;

class Complex {
private:
    double re, im;

public:
    Complex(double r = 0, double i = 0) : re(r), im(i) {}

    // + 연산자 오버로딩
    Complex operator+(const Complex& c) const { // (1)
        return Complex(re + c.re, im + c.im);
    }

    Complex operator+(const double r) const {   // (2)
        return Complex(re + r, im);
    }

    friend Complex operator+(const double r, const Complex& c); // (3)

    // - 연산자 오버로딩
    Complex operator-(const Complex& c) const { // (4)
        return Complex(re - c.re, im - c.im);
    }

    Complex operator-(const double r) const {   // (5)
        return Complex(re - r, im);
    }

    friend Complex operator-(const double r, const Complex& c); // (6)

    void print() const {
        cout << re << " + " << im << "i" << endl;
    }
};

// friend 함수를 통한 + 연산자 오버로딩 (3)
Complex operator+(const double r, const Complex& c) {
    return Complex(r + c.re, c.im);
}

// friend 함수를 통한 - 연산자 오버로딩 (6)
Complex operator-(const double r, const Complex& c) {
    return Complex(r - c.re, -c.im);
}

int main() {
    Complex c1(1, 0), c2(0, 1);

    Complex c3 = c1 + c2;    // (1) Complex + Complex
    Complex c4 = c1 + 10;    // (2) Complex + double
    Complex c5 = 10 + c1;    // (3) double + Complex
    Complex c6 = c1 - c2;    // (4) Complex - Complex
    Complex c7 = c1 - 10;    // (5) Complex - double
    Complex c8 = 10 - c1;    // (6) double - Complex

    c3.print();
    c4.print();
    c5.print();
    c6.print();
    c7.print();
    c8.print();

    return 0;
}

 

 

 

대입 연산자(Assignment Operator) '=' 의 복사(Copy)

 

Copy Assignment Operator는 이미 생성된 객체에 다른 객체의 값을 대입하는 연산자를 정의하는 함수입니다. 만약 클래스가 동적 메모리 할당(예: new를 사용하여 포인터로 메모리를 할당)을 포함하는 멤버를 가지고 있다면, 깊은 복사(Deep Copy)를 사용해야 합니다. 그렇지 않으면 얕은 복사(Shallow Copy)로 인해 원본 객체와 복사된 객체가 같은 메모리 주소를 참조하게 되어, 하나의 객체에서 메모리를 해제할 때 다른 객체에서도 접근할 수 없게 되는 문제가 발생할 수 있다.

 

ex)

#include <iostream>
#include <cstring> // std::strlen, std::strcpy

class MyString {
private:
    char* str; // 동적 메모리 할당을 사용하는 문자열

public:
    // 생성자
    MyString(const char* s = "") {
        str = new char[std::strlen(s) + 1];
        std::strcpy(str, s);
    }

    // 소멸자
    ~MyString() {
        delete[] str;
    }

    // 복사 생성자 (깊은 복사 사용)
    MyString(const MyString& other) {
        str = new char[std::strlen(other.str) + 1];
        std::strcpy(str, other.str);
    }

    // Copy Assignment Operator (깊은 복사 사용)
    MyString& operator=(const MyString& other) {
        if (this == &other) {
            return *this; // 자기 자신에 대한 대입을 방지
        }

        // 기존에 할당된 메모리 해제
        delete[] str;

        // 새로운 메모리 공간을 할당하고, 데이터를 깊은 복사
        str = new char[std::strlen(other.str) + 1];
        std::strcpy(str, other.str);

        return *this;
    }

    // 문자열 출력
    void print() const {
        std::cout << str << std::endl;
    }
};

int main() {
    MyString str1("Hello, World!");
    MyString str2;

    str2 = str1;  // Copy Assignment Operator 호출

    str1.print(); // Hello, World!
    str2.print(); // Hello, World!

    str1 = "Goodbye!";  // 새로운 문자열 대입 (임시 객체 생성 후 대입)

    str1.print(); // Goodbye!
    str2.print(); // Hello, World! (str1의 변경이 str2에 영향을 주지 않음)

    return 0;
}

 

이미 존재하는 객체에 다른 객체를 대입할 때 호출된다

자기 자신과의 대입을 방지한 후, 기존에 할당된 메모리를 해제하고 새로운 메모리 공간을 할당하여 깊은 복사를 수행한다

 

C++ Shallow Copy(얕은 복사)와 Deep Copy(깊은 복사)

 

 

 

 

Conversion Operator (형변환 연산자)

Conversion Operator는 클래스의 객체를 특정 타입으로 변환하는 방법을 정의하는 것을 말한다. 이를 통해 클래스 객체를 다른 기본 데이터 타입으로 변환할 수 있다.

 

#include <iostream>

class MyClass {
private:
    int value; // 저장할 값

public:
    // 생성자
    MyClass(int v) : value(v) {}

    operator double() const {        // Conversion Operator를 정의
        return static_cast<double>(value);
    }
};

int main() {
    MyClass obj(10);

    // 묵시적 변환 예제
    double d = obj; // MyClass 객체가 자동으로 double로 변환됨
    std::cout << "묵시적 변환된 값: " << d << std::endl;

    // 명시적 변환 예제
    double explicitDouble = static_cast<double>(obj);
    std::cout << "명시적 변환된 값: " << explicitDouble << std::endl;

    return 0;
}