c++ friend ( operator override -1 )

일단 작성중 - 코드만 붙혀놓고 나중에.

#include <iostream>
using namespace std;
class NUMBOX
{
private:
    int num1, num2;
public:
    NUMBOX(int num1, int num2) : num1(num1), num2(num2) { }
    void ShowNumber(){
        cout << "num1: " << num1 << ", num2: " << num2 << endl;
    }
//    NUMBOX operator+(NUMBOX &ref) {
//        return NUMBOX(num1+ ref.num1, num2+ref.num2);
//    }
    NUMBOX operator+(int numb) {
        return NUMBOX(num1 + numb, num2 + numb);
    }
    friend NUMBOX operator+(int num, NUMBOX ref);
// friend 가 붙은 이유는 이 함수가 클래스의 멤버함수가 아니라서,
// 즉 nb1.operator+ 로 접근 할 수 없는 함수이기 때문에 friend가 붙어야한다.
// 그리고 전역함수로 넣어준다.
};

NUMBOX operator+(int num, NUMBOX ref) {
    ref.num1 += num;
    ref.num2 += num;
    return ref;
}

int main()
{
    NUMBOX nb1(10, 20);
    NUMBOX nb2(5, 2);
    NUMBOX result = 10 + nb1 + 30;
    // NUMBOX result = nb1 + nb2;
    // NUMBOX result = nb1.operator+(nb2);
    // NUMBOX result = nb1.operator+(10);
    // NUMBOX result = nb1 + 10; <=> NUMBOX result = 10 + nb1; 은 안된다.
    // nb1에 있는 num1 과 num2에 10씩 더하고 return 한다.
    nb1.ShowNumber();
    nb2.ShowNumber();
    result.ShowNumber();
}

• https://blog.hexabrain.net/177
• 보고 공부 中

#include <iostream>
using namespace std;

class Point {
private:
    int x, y;
public:
    Point(int num = 10):x(num), y(num){ };
    Point(int _x=0, int _y=0):x(_x), y(_y){ }; // 타입 값 못 붙힘
    void ShowPosition();
    int getX() const { return x; };
    int getY() const { return y; };
    // "const 참초" 를한 class를 이용하여 함수를 멤버함수를 접근 하기 위해서는
    // 멤버함수 가 class의 값을 바꾸지 않는 다는 것을 알리기 위해서
    // 함수 선언시 ( 함수 명 뒤에 const를 붙혀줘야한다.

//    const Point operator+(const Point& p2) const;
    // 리턴 값으로 const Point 를 리턴하고
    // 호출하는 객체 또한 const로 호출된다는 뜻.
    // 또한 안에 있는 매게변수도 const로 사용된다.
    // 멤버 함수로 기본연산자를 오버라이딩 할 경우,
    // 왼 => 오 계산이 확실히 보장 못 받을 수 있기 때문에 안티패턴(?) 인 것 같다.

    const Point friend operator+ (int num, const Point& p1);
    //friend 함수는 멤버함수가 아니기 때문에 함수에 const를 붙혀서 이 함수가 호출함수의 값을 바꾸지 않는다는
    // 것을 알릴 필요가 없다. 왜냐하면 어차피 호출함수가 없기 때문이다.
};
void Point::ShowPosition(){
    cout<<x<<" "<<y<<endl;
}

// 정의 부에서는 friend 를 같이 넣어주지 않아야한다.
const Point operator+(int num, const Point& p1)  {
    return Point(p1.x + num, p1.y + num);
} // 동일 기본연산자 오버로딩, 오버라이딩가능

const Point operator+(const Point& p1, const Point& p2) {
    return Point(p1.getX() + p2.getX(), p1.getY() + p2.getY());
} // 객체의 매개 함수로 기본연산자를 오버로딩 하는 것이 아닌,
// 전역함수로 객체의 기본연산자를 오버로딩을 하게 된다면,
// classOne.operator+(classTwo) 이런식으로 하지 못한다.
// 하지만, classOne + classTwo 는 가능하다
// [ 객채.멤버요소 ] 로 구성 된 것은, 객체의 맴버요소로서 접근을 하는 것이기 때문인거 같다.

//const Point Point::operator+(const Point& p2) const{
//    return Point(x + p2.x, y + p2.y);
// 다른 코드 처리 없이 p2.x , p2.y 에 접근 가능한 이유는
// p2 또한 Point class이기 때문에 ( 호출함수와 메게변수의 함수의 type이 같기 때문에 )
// private 요소에 접근 가능하기 때문이다.
//}

//const Point operator+(const Point& p1, const Point& p2) {
//    return Point(x + p2.x, y + p2.y); => 이건 안됌 ( 이유 : 호출함수 가 없기 때문에. )
//    return Point(p1.x + p2.x, p1.y + p2.y);
//}

int main(void)
{
    Point p1(1, 2);
    Point p2(2, 1);
    Point p3 = p1 +p2;
    Point p4 = 10 + p1;
    p3.ShowPosition();
    p4.ShowPosition();
    return 0;
}

#include <iostream>


class Test {
    int x;

public:
    Test(int x) : x(x) {}
    Test(const Test& t) : x(t.x) {}

    // ++t const Test& operator++(){};
    // t++ const Test& operator++(int){};

    const Test& operator++() {
        x++;
        std::cout << "전위 증감 연산자" << std::endl;
        return *this;
    }

    // 전위 증감과 후위 증감에 차이를 두기 위해 후위 증감의 경우 인자로 int 를
    // 받지만 실제로는 아무것도 전달되지 않는다.

    // 후위 연산자는 return 을 연산되는 값을 그대로 반환한다.
    // temp 라는 본래 값을 복사해서 다시 return 한다.
    // 그 사이에 호출객체의 x 를 ++ 해준다.
    // t++
    const Test operator++(int) {
        Test temp(*this);
        x++;
        std::cout << "후위 증감 연산자" << std::endl;
        return temp;
    }

    const int get_x() const {
        return x;
    }
};

void func(const Test& t) {
    std::cout << "x : " << t.get_x() << std::endl;
}

int main() {
    Test t(3);

    func(++t); // 4
    func(t++); // 4 가 출력됨
    std::cout << "x : " << t.get_x() << std::endl;
}