【C++】演算子オーバーロードのやり方：書き方・注意点・実例を解説

Vector2D a(1.0, 2.0);
Vector2D b(3.0, 4.0);

// 演算子オーバーロードを行うことで、数値型と同じような書き方ができる
Vector2D c = a + b;

#include <iostream>

// 2次元ベクトルを表すクラス
class Vector2 {
public:
    double x;
    double y;

    // コンストラクタ
    Vector2(double x_ = 0.0, double y_ = 0.0)
        : x(x_), y(y_) {}
};

class Vector2 {
public:
    double x;
    double y;

    Vector2(double x_ = 0.0, double y_ = 0.0)
        : x(x_), y(y_) {}

    // ベクトル同士の加算 (a + b)
    Vector2 operator+(const Vector2& rhs) const {
        // ここで新しいVector2を作って返す
        return Vector2(this->x + rhs.x, this->y + rhs.y);
    }

    // ベクトル同士の減算 (a - b)
    Vector2 operator-(const Vector2& rhs) const {
        return Vector2(this->x - rhs.x, this->y - rhs.y);
    }
};

class Vector2 {
    // ... (略)

    // 単項マイナス (-a)
    Vector2 operator-() const {
        return Vector2(-x, -y);
    }
};

class Vector2 {
    // ... (略)

    // ベクトル * スカラー (v * s)
    Vector2 operator*(double s) const {
        return Vector2(x * s, y * s);
    }
};

// ベクトル * スカラー (メンバー関数で定義済み)
// Vector2 Vector2::operator*(double s) const;

// スカラー * ベクトル (2.0 * v) をサポートするフリー関数
Vector2 operator*(double s, const Vector2& v) {
    // 実装は v * s に委譲してもよい
    return v * s;
}

class Vector2 {
public:
    double x;
    double y;

    Vector2(double x_ = 0.0, double y_ = 0.0)
        : x(x_), y(y_) {}
};

// ベクトル同士の等価比較 (a == b)
bool operator==(const Vector2& lhs, const Vector2& rhs) {
    return lhs.x == rhs.x && lhs.y == rhs.y;
}

// ベクトル同士の非等価比較 (a != b)
bool operator!=(const Vector2& lhs, const Vector2& rhs) {
    return !(lhs == rhs);  // == に処理を委譲
}

#include <iostream>

class Vector2 {
public:
    double x;
    double y;

    Vector2(double x_ = 0.0, double y_ = 0.0)
        : x(x_), y(y_) {}
};

// 出力用の演算子オーバーロード
std::ostream& operator<<(std::ostream& os, const Vector2& v) {
    // 好きな形式で出力形式を決められる
    os << "(" << v.x << ", " << v.y << ")";
    return os;  // 連結 (cout << v1 << v2;) を可能にするため参照を返す
}

int main() {
    Vector2 a(1.0, 2.0);
    Vector2 b(3.5, -1.2);

    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;
    std::cout << "a + b = " << (a + b) << std::endl;
}

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

    // 前置インクリメント (++i)
    Counter& operator++() {
        ++value;      // まず自分をインクリメント
        return *this; // その結果の参照を返す
    }

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

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

    // 前置インクリメント (++i)
    Counter& operator++() {
        ++value;
        return *this;
    }

    // 後置インクリメント (i++)
    Counter operator++(int) {
        Counter old(*this); // 変更前の状態を保存
        ++value;            // 自分をインクリメント
        return old;         // 変更前の値を返す
    }

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

int main() {
    Counter c(5);

    Counter a = ++c; // 前置: cは6になり、aも6
    Counter b = c++; // 後置: cは7になるが、bは6(インクリメント前の値)

    std::cout << "c = " << c.get() << std::endl;
    std::cout << "a = " << a.get() << std::endl;
    std::cout << "b = " << b.get() << std::endl;
}

class Vector2 {
    double x;
    double y;
public:
    Vector2(double x_ = 0.0, double y_ = 0.0)
        : x(x_), y(y_) {}

    // フリー関数からプライベートメンバーにアクセスできるようにする
    friend Vector2 operator+(const Vector2& lhs, const Vector2& rhs);
};

// フリー関数としてoperator+を定義
Vector2 operator+(const Vector2& lhs, const Vector2& rhs) {
    return Vector2(lhs.x + rhs.x, lhs.y + rhs.y);
}

// a + b は新しい値を返す: 値で返す
Vector2 operator+(const Vector2& lhs, const Vector2& rhs);

// a += b は自分を更新して自分を返す: 参照で返す
Vector2& operator+=(Vector2& lhs, const Vector2& rhs);