연산자 오버로딩 기초

Point p1(1, 2);
Point p2(3, 4);
// Point p3 = p1 + p2; // 컴파일 오류! Point 타입에 대한 + 연산자가 정의되어 있지 않음

// 멤버 함수로 오버로딩
반환타입 operator연산자(매개변수1, 매개변수2, ...) {
    // 연산자 동작 정의
}

// 비멤버 함수 (전역 함수)로 오버로딩
반환타입 operator연산자(매개변수1, 매개변수2, ...) {
    // 연산자 동작 정의
}

#pragma once
#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int _x = 0, int _y = 0) : x(_x), y(_y) {} // 기본값 인자를 가진 생성자

    // Getter 함수 (const 멤버 함수)
    int getX() const { return x; }
    int getY() const { return y; }

    // 1. 멤버 함수로 + 연산자 오버로딩
    // Point 객체를 더하면 새로운 Point 객체를 반환
    Point operator+(const Point& other) const; // const는 현재 객체의 상태를 변경하지 않음을 의미

    // 2. << 연산자 오버로딩을 위한 friend 선언 (뒤에서 다시 다룸)
    friend std::ostream& operator<<(std::ostream& os, const Point& p);
};

#include "Point.h"

// 1. 멤버 함수로 + 연산자 오버로딩 정의
// 현재 Point 객체(this)와 other Point 객체를 더하여 새로운 Point 객체를 반환
Point Point::operator+(const Point& other) const {
    // 새로운 Point 객체를 생성하여 x, y 좌표를 더한 값으로 초기화
    return Point(this->x + other.x, this->y + other.y);
}

// 2. << 연산자 오버로딩 정의 (friend 함수이므로 클래스 외부에서 정의)
// Point::operator<< 가 아님!
std::ostream& operator<<(std::ostream& os, const Point& p) {
    os << "(" << p.x << ", " << p.y << ")"; // private 멤버 x, y에 직접 접근 가능 (friend라서)
    return os;
}

#include "Point.h" // Point 클래스 헤더 포함

int main() {
    Point p1(1, 2);
    Point p2(3, 4);

    // + 연산자 오버로딩 사용
    Point p3 = p1 + p2; // p1.operator+(p2) 와 동일

    std::cout << "p1: " << p1 << std::endl; // 출력: p1: (1, 2)
    std::cout << "p2: " << p2 << std::endl; // 출력: p2: (3, 4)
    std::cout << "p1 + p2 = p3: " << p3 << std::endl; // 출력: p1 + p2 = p3: (4, 6)

    Point p4 = p3 + Point(10, 20); // 임시 객체와도 연산 가능
    std::cout << "p3 + (10,20) = p4: " << p4 << std::endl; // 출력: p3 + (10,20) = p4: (14, 26)

    return 0;
}

// ... (기존 Point 클래스 내용) ...
class Point {
    // ... (기존 멤버 변수 및 생성자, getter) ...
public:
    // 멤버 함수로 + 연산자 오버로딩
    Point operator+(const Point& other) const;

    // 단항 - 연산자 오버로딩 (멤버 함수)
    Point operator-() const; // 매개변수 없음

    friend std::ostream& operator<<(std::ostream& os, const Point& p);
};

#include "Point.h"

// 단항 - 연산자 오버로딩 정의
// 현재 Point 객체의 각 좌표를 음수로 바꾸어 새로운 Point 객체를 반환
Point Point::operator-() const {
    return Point(-this->x, -this->y);
}

// ... (기존 + 연산자 및 << 연산자 정의) ...

#include "Point.h"

int main() {
    Point p1(1, 2);
    std::cout << "p1: " << p1 << std::endl; // 출력: p1: (1, 2)

    Point p_neg = -p1; // 단항 - 연산자 오버로딩 사용 (p1.operator-() 와 동일)
    std::cout << "-p1: " << p_neg << std::endl; // 출력: -p1: (-1, -2)

    return 0;
}

// << (출력) 연산자 오버로딩
std::ostream& operator<<(std::ostream& os, const 클래스이름& 객체) {
    // os에 객체의 내용을 출력
    return os; // 연속적인 출력을 위해 os 참조자를 반환
}

// >> (입력) 연산자 오버로딩
std::istream& operator>>(std::istream& is, 클래스이름& 객체) {
    // is에서 데이터를 읽어 객체에 저장
    return is; // 연속적인 입력을 위해 is 참조자를 반환
}

#include <iostream>

class Vec2 {
private:
    int x;
    int y;

public:
    Vec2(int _x = 0, int _y = 0) : x(_x), y(_y) {}

    // 핵심 로직은 +=에 모은다
    Vec2& operator+=(const Vec2& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this; // 연쇄 대입 지원
    }

    // +는 복사본을 만든 뒤 +=를 호출
    Vec2 operator+(const Vec2& rhs) const {
        Vec2 temp(*this);
        temp += rhs;
        return temp;
    }

    friend std::ostream& operator<<(std::ostream& os, const Vec2& v) {
        os << "(" << v.x << ", " << v.y << ")";
        return os;
    }
};

int main() {
    Vec2 a(1, 2), b(3, 4);
    Vec2 c = a + b; // (4, 6)
    a += b;         // a도 (4, 6)

    std::cout << "c = " << c << "\n";
    std::cout << "a = " << a << "\n";
}

class MyType {
public:
    MyType& operator=(const MyType& rhs);      // Copy Assignment
    MyType& operator=(MyType&& rhs) noexcept;  // Move Assignment
};

#include <iostream>

class Counter {
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    // 전위 ++ : 증가 후 자신 반환
    Counter& operator++() {
        ++value;
        return *this;
    }

    // 후위 ++ : 이전 값 복사본 반환
    Counter operator++(int) {
        Counter old(*this);
        ++value;
        return old;
    }

    int get() const { return value; }
};

int main() {
    Counter c(10);

    Counter a = ++c; // c=11, a=11
    Counter b = c++; // c=12, b=11

    std::cout << "a: " << a.get() << ", b: " << b.get() << ", c: " << c.get() << "\n";
}

class Value {
public:
    Value operator+(const Value& rhs) const;
    Value& operator+=(const Value& rhs);
    bool operator==(const Value& rhs) const noexcept;
    Value& operator=(Value&& rhs) noexcept;
};