[C++] 演算子のオーバーロードについて詳しく解説

#include <iostream>
class Point {
public:
    int x, y;
    // コンストラクタ
    Point(int x, int y) : x(x), y(y) {}
    // 加算演算子のオーバーロード
    Point operator+(const Point& other) {
        return Point(x + other.x, y + other.y);
    }
};
int main() {
    Point p1(1, 2); // Pointオブジェクトp1を作成
    Point p2(3, 4); // Pointオブジェクトp2を作成
    Point p3 = p1 + p2; // p1とp2を加算
    std::cout << "p3の座標: (" << p3.x << ", " << p3.y << ")" << std::endl; // p3の座標を出力
    return 0;
}

p3の座標: (4, 6)

#include <iostream>
class Vector {
public:
    int x, y;
    // コンストラクタ
    Vector(int x, int y) : x(x), y(y) {}
    // 減算演算子のオーバーロード
    Vector operator-(const Vector& other) {
        return Vector(x - other.x, y - other.y);
    }
    // 比較演算子のオーバーロード
    bool operator==(const Vector& other) {
        return (x == other.x && y == other.y);
    }
};
int main() {
    Vector v1(5, 3); // Vectorオブジェクトv1を作成
    Vector v2(2, 1); // Vectorオブジェクトv2を作成
    Vector v3 = v1 - v2; // v1からv2を減算
    std::cout << "v3の座標: (" << v3.x << ", " << v3.y << ")" << std::endl; // v3の座標を出力
    // v1とv2が等しいかを比較
    if (v1 == v2) {
        std::cout << "v1とv2は等しいです。" << std::endl;
    } else {
        std::cout << "v1とv2は等しくありません。" << std::endl;
    }
    return 0;
}

v3の座標: (3, 2)
v1とv2は等しくありません。

#include <iostream>
class Counter {
public:
    int value;
    // コンストラクタ
    Counter(int value) : value(value) {}
    // インクリメント演算子のオーバーロード(前置)
    Counter& operator++() {
        ++value; // 値をインクリメント
        return *this; // 自分自身を返す
    }
    // 符号反転演算子のオーバーロード
    Counter operator-() {
        return Counter(-value); // 値の符号を反転
    }
};
int main() {
    Counter c(5); // Counterオブジェクトcを作成
    ++c; // cをインクリメント
    std::cout << "インクリメント後の値: " << c.value << std::endl; // 値を出力
    Counter negC = -c; // cの符号を反転
    std::cout << "符号反転後の値: " << negC.value << std::endl; // 符号反転後の値を出力
    return 0;
}

インクリメント後の値: 6
符号反転後の値: -6

#include <iostream>
class Rectangle {
public:
    int width, height;
    // コンストラクタ
    Rectangle(int width, int height) : width(width), height(height) {}
    // 等しい演算子のオーバーロード
    bool operator==(const Rectangle& other) {
        return (width == other.width && height == other.height);
    }
    // より大きい演算子のオーバーロード
    bool operator>(const Rectangle& other) {
        return (width * height > other.width * other.height); // 面積で比較
    }
};
int main() {
    Rectangle rect1(4, 5); // Rectangleオブジェクトrect1を作成
    Rectangle rect2(4, 5); // Rectangleオブジェクトrect2を作成
    Rectangle rect3(3, 6); // Rectangleオブジェクトrect3を作成
    // rect1とrect2が等しいかを比較
    if (rect1 == rect2) {
        std::cout << "rect1とrect2は等しいです。" << std::endl;
    } else {
        std::cout << "rect1とrect2は等しくありません。" << std::endl;
    }
    // rect1とrect3の面積を比較
    if (rect1 > rect3) {
        std::cout << "rect1の方が大きいです。" << std::endl;
    } else {
        std::cout << "rect3の方が大きいか、同じ大きさです。" << std::endl;
    }
    return 0;
}

rect1とrect2は等しいです。
rect1の方が大きいです。

#include <iostream>
class Person {
public:
    std::string name;
    int age;
    // コンストラクタ
    Person(std::string name, int age) : name(name), age(age) {}
    // 出力演算子のオーバーロード
    friend std::ostream& operator<<(std::ostream& os, const Person& person) {
        os << "名前: " << person.name << ", 年齢: " << person.age; // 出力形式を定義
        return os; // ストリームを返す
    }
    // 入力演算子のオーバーロード
    friend std::istream& operator>>(std::istream& is, Person& person) {
        std::cout << "名前を入力してください: ";
        is >> person.name; // 名前を入力
        std::cout << "年齢を入力してください: ";
        is >> person.age; // 年齢を入力
        return is; // ストリームを返す
    }
};
int main() {
    Person p("山田太郎", 30); // Personオブジェクトpを作成
    // Personオブジェクトの情報を出力
    std::cout << p << std::endl;
    // 新しいPersonオブジェクトを作成
    Person p2("", 0);
    std::cin >> p2; // 入力を受け取る
    // 入力された情報を出力
    std::cout << "入力された情報: " << p2 << std::endl;
    return 0;
}

名前: 山田太郎, 年齢: 30
名前を入力してください: 佐藤花子
年齢を入力してください: 25
入力された情報: 名前: 佐藤花子, 年齢: 25

#include <iostream>
class Calculator {
public:
    // 代入演算子のオーバーロード
    Calculator& operator=(const Calculator& other) {
        // 自己代入のチェック
        if (this != &other) {
            // ここでは特に何もコピーしないが、必要に応じて処理を追加
        }
        return *this; // 自分自身を返す
    }
    // 関数呼び出し演算子のオーバーロード
    int operator()(int a, int b) {
        return a + b; // 2つの数値を加算
    }
};
int main() {
    Calculator calc1; // Calculatorオブジェクトcalc1を作成
    Calculator calc2; // Calculatorオブジェクトcalc2を作成
    // 代入演算子を使用
    calc2 = calc1; // calc1をcalc2に代入
    // 関数呼び出し演算子を使用
    int result = calc1(3, 4); // 3と4を加算
    std::cout << "3 + 4 = " << result << std::endl; // 結果を出力
    return 0;
}

3 + 4 = 7