成员函数 与 运算符重载

class Point {
private:
    int x = 0, y = 0;              // 类内默认初始化，让 const Point p; 合法
public:
    int getX()       { return x; }         // ❌ 少写 const
    int getY() const { return y; }         // ✅ 正确
};

void f(const Point& p) {
    cout << p.getY();     // ✅ 可以，getY 是 const 成员函数
    cout << p.getX();     // ❌ error: passing 'const Point' as 'this' argument discards qualifiers
}

int main() {
    const Point p;
    p.getY();             // ✅
    p.getX();             // ❌ 同样报错
}

class Array {
private:
    vector<int> a;
public:
    int&       operator[](int i)       { return a[i]; }   // 可写版本
    const int& operator[](int i) const { return a[i]; }   // 只读版本
};

Array arr;
arr[0] = 5;          // 调用可写版本，可以赋值

const Array& carr = arr;
cout << carr[0];     // 调用只读版本
carr[0] = 6;       // ❌ 编译错误：const 版本返回 const 引用，不能赋值

// 你写的：
Complex c = a + b;

// 编译器理解成（成员形式）：
Complex c = a.operator+(b);

// 或者（全局/友元形式）：
Complex c = operator+(a, b);

// 也就是说，这三种写法完全等价：
cout << a + b << endl;
cout << a.operator+(b) << endl;
cout << operator+(a, b) << endl;

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

    // 类内声明为友元（不是成员函数！）
    friend ostream& operator<<(ostream& os, const Complex& c);
};

// 类外定义：注意不要写 friend，也不要写 Complex::
ostream& operator<<(ostream& os, const Complex& c) {
    os << c.re << (c.im >= 0 ? "+" : "") << c.im << "i";
    return os;                     // ★ 必须返回流本身
}

// 使用：
Complex c(3, -4);
cout << "c = " << c << endl;       // c = 3-4i

// ── 写法 A：友元（全局）形式，推荐 ────────────────
struct Stu {
    string name;
    int tot;
    // 总分高的排前面；总分相同时名字字典序小的排前面
    friend bool operator<(const Stu& a, const Stu& b) {
        if (a.tot != b.tot) return a.tot > b.tot;
        return a.name < b.name;
    }
};

// ── 写法 B：成员形式，也可以 ──────────────────────
struct Stu2 {
    string name; int tot;
    bool operator<(const Stu2& o) const {
        if (tot != o.tot) return tot > o.tot;
        return name < o.name;
    }
};

// ── 有了它，三种容器全部可用 ──────────────────────
vector<Stu> v;
sort(v.begin(), v.end());        // ✅ 不需要第三个参数了

set<Stu> s;                      // ✅ 终于能用了

priority_queue<Stu> pq;          // ✅ 也能用了

#include <bits/stdc++.h>
using namespace std;

struct P {
    int x, y;

    // ── 输出：教 cout 怎么打印一个 P ──
    friend ostream& operator<<(ostream& os, const P& p) {
        os << "(" << p.x << "," << p.y << ")";
        return os;                    // ★ 返回流，支持链式
    }

    // ── 输入：教 cin 怎么读一个 P ──
    friend istream& operator>>(istream& is, P& p) {
        is >> p.x >> p.y;
        return is;                    // ★ 返回流，支持链式
    }
};

int main() {
    P a, b;
    cin >> a >> b;                      // 一行读入两个点
    cout << "a = " << a << ", b = " << b << endl;

    vector<P> v{a, b};
    for (const P& p : v) cout << p << " ";   // 输出整个容器
    cout << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct Vec {
    double x, y;
    Vec(double x = 0, double y = 0) : x(x), y(y) {}

    // ── 算术运算符：返回新对象（值） ──
    Vec operator+(const Vec& o) const { return Vec(x + o.x, y + o.y); }
    Vec operator-(const Vec& o) const { return Vec(x - o.x, y - o.y); }
    Vec operator*(double k)        const { return Vec(x * k, y * k); }

    // ── 几何运算（不需要运算符，用函数名更清楚） ──
    double dot(const Vec& o)   const { return x * o.x + y * o.y; }   // 点积
    double cross(const Vec& o) const { return x * o.y - y * o.x; }   // 叉积
    double len2()              const { return x * x + y * y; }       // 长度平方

    // ── 比较运算符 ──
    bool operator==(const Vec& o) const { return x == o.x && y == o.y; }
    bool operator<(const Vec& o) const {                       // 严格弱序
        if (x != o.x) return x < o.x;
        return y < o.y;
    }

    // ── 全局形式：让「标量 * 向量」两个方向都能写 ──
    friend Vec operator*(double k, const Vec& v) { return v * k; }

    // ── 输出：调试时直接 cout << v ──
    friend ostream& operator<<(ostream& os, const Vec& v) {
        return os << "(" << v.x << "," << v.y << ")";
    }
};

int main() {
    Vec a(3, 4), b(1, 2);
    cout << "a     = " << a << endl;
    cout << "b     = " << b << endl;
    cout << "a+b   = " << a + b << endl;
    cout << "a-b   = " << a - b << endl;
    cout << "a*2   = " << a * 2 << endl;      // 成员形式
    cout << "2*a   = " << 2 * a << endl;      // 全局形式，缺了就编不过
    cout << "a·b   = " << a.dot(b) << endl;
    cout << "a×b   = " << a.cross(b) << endl;
    cout << "|a|   = " << sqrt(a.len2()) << endl;
    cout << "a==b? " << (a == b) << endl;

    vector<Vec> v{Vec(5, 1), Vec(1, 9), Vec(5, 0), Vec(0, 7)};
    sort(v.begin(), v.end());          // 只认 operator<，不用传比较器
    cout << "排序后：";
    for (const Vec& p : v) cout << p << " ";
    cout << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct BigNum {
    string s;                       // 无前导零

    void trim() {                   // 去掉前导零（保留最后一位，保证 "0" 不变成空串）
        int i = 0;
        while (i + 1 < (int)s.size() && s[i] == '0') i++;
        s = s.substr(i);
    }

    // ★ 核心：数值序 = 先比位数，位数相同再比字典序
    bool operator<(const BigNum& o) const {
        if (s.size() != o.s.size()) return s.size() < o.s.size();
        return s < o.s;
    }
    bool operator==(const BigNum& o) const { return s == o.s; }

    friend ostream& operator<<(ostream& os, const BigNum& b) { return os << b.s; }
};

// ── 错误示范：只写了普通比较函数 ──
bool cmp(const BigNum& a, const BigNum& b) { return a < b; }

int main() {
    int n; cin >> n;
    vector<BigNum> v(n);
    for (BigNum& b : v) { cin >> b.s; b.trim(); }

    // ① sort 用普通比较函数：可以
    sort(v.begin(), v.end(), cmp);
    cout << "排序：";
    for (const BigNum& b : v) cout << b << " ";
    cout << endl;

    // ② set 不接受 cmp，只能靠 operator<
    set<BigNum> st;
    for (const BigNum& b : v) st.insert(b);
    cout << "去重后 " << st.size() << " 个：";
    for (const BigNum& b : st) cout << b << " ";
    cout << endl;

    // ③ map 的键同理，必须有 operator<
    map<BigNum, int> mp;
    for (const BigNum& b : v) mp[b]++;
    cout << "出现次数最多的大数位数：" << mp.rbegin()->first.s.size() << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct Task {
    int d, id;                      // d = 截止时间
    friend ostream& operator<<(ostream& os, const Task& t) { return os << t.id; }
};

// ── 注意 1：priority_queue 是【大根堆】 ──
// 它会把 cmp(a,b) 返回 false 的一方放到堆顶。
// 想让 d 小的在堆顶，就要让「d 小的」在 cmp 里显得「更大」
// 即：返回 a.d > b.d 表示 a 比 b 小 → 堆顶是 d 最小的
//
// ── 注意 2：operator() 必须加 const！──
// priority_queue 内部持有的是 const 的比较器对象，
// 漏掉 const 会报一屏「discards qualifiers」的错
struct CmpTask {
    bool operator()(const Task& a, const Task& b) const {     // ★ const 不能漏
        if (a.d != b.d) return a.d > b.d;
        return a.id > b.id;
    }
};

int main() {
    int n; cin >> n;
    priority_queue<Task, vector<Task>, CmpTask> pq;
    for (int i = 0; i < n; i++) {
        int d, id; cin >> d >> id;
        pq.push({d, id});
    }
    cout << "处理顺序：";
    while (!pq.empty()) {
        cout << pq.top() << " ";
        pq.pop();
    }
    cout << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

class Complex {
private:
    double re, im;
public:
    Complex(double r = 0, double i = 0) : re(r), im(i) {}
    double real() const { return re; }
    double imag() const { return im; }
    double mod2() const { return re * re + im * im; }

    // ── 二元算术：返回新对象（值） ──
    Complex operator+(const Complex& o) const { return Complex(re + o.re, im + o.im); }
    Complex operator-(const Complex& o) const { return Complex(re - o.re, im - o.im); }
    Complex operator*(const Complex& o) const {
        return Complex(re * o.re - im * o.im, re * o.im + im * o.re);
    }

    // ── 一元负号：参数个数为 0 ──
    Complex operator-() const { return Complex(-re, -im); }

    // ── 复合赋值：返回自己的引用，支持连续运算 ──
    Complex& operator+=(const Complex& o) { re += o.re; im += o.im; return *this; }
    Complex& operator*=(const Complex& o) { *this = *this * o; return *this; }

    // ── 比较：== 与 != 成对出现 ──
    bool operator==(const Complex& o) const { return re == o.re && im == o.im; }
    bool operator!=(const Complex& o) const { return !(*this == o); }

    // ── 全局形式：支持「标量 * 复数」 ──
    friend Complex operator*(double k, const Complex& c) {
        return Complex(k * c.re, k * c.im);
    }

    // ── 输出：教 cout 怎么念一个复数 ──
    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << c.re;
        if (c.im >= 0) os << "+";
        return os << c.im << "i";
    }
};

int main() {
    Complex a(3, -4), b(1, 2);
    cout << "a        = " << a << endl;
    cout << "b        = " << b << endl;
    cout << "a+b      = " << a + b << endl;
    cout << "a-b      = " << a - b << endl;
    cout << "a*b      = " << a * b << endl;
    cout << "-a       = " << -a << endl;
    cout << "2.5*a    = " << 2.5 * a << endl;
    Complex c = a;
    c += b; c *= b;
    cout << "(a+b)*b  = " << c << endl;
    cout << "a==b? " << (a == b) << " a!=b? " << (a != b) << endl;
    cout << "|a|^2    = " << a.mod2() << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct Frac {
    long long n, d;                 // 不变式：d > 0 且已约分

    Frac(long long n = 0, long long d = 1) : n(n), d(d) { simplify(); }

    void simplify() {               // 约分 + 规范符号
        if (d < 0) { n = -n; d = -d; }
        long long g = __gcd(abs(n), d);
        if (g) { n /= g; d /= g; }
    }

    Frac operator+(const Frac& o) const {           // 返回新对象
        return Frac(n * o.d + o.n * d, d * o.d);    // 构造即约分
    }

    bool operator<(const Frac& o) const {           // 交叉相乘比较
        return n * o.d < o.n * d;
    }

    friend ostream& operator<<(ostream& os, const Frac& f) {
        return os << f.n << "/" << f.d;
    }
};

int main() {
    int N; scanf("%d", &N);
    vector<Frac> v(N);
    for (int i = 0; i < N; i++) {
        long long a, b;
        scanf("%lld/%lld", &a, &b);
        v[i] = Frac(a, b);
    }

    sort(v.begin(), v.end());                  // 只认 operator<
    for (int i = 0; i < N; i++) {
        if (i) putchar(' ');
        cout << v[i];
    }
    putchar('\n');

    Frac sum(0, 1);
    for (int i = 0; i < N; i++) sum = sum + v[i];   // 每步都自动约分
    cout << sum << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct P {
    long long x, y;

    long long dist() const { return llabs(x) + llabs(y); }   // 曼哈顿距离

    bool operator<(const P& o) const {
        long long da = dist(), db = o.dist();
        if (da != db) return da < db;      // 第一关键字：距离
        if (x != o.x) return x < o.x;      // 第二关键字：x
        return y < o.y;                    // 第三关键字：y
    }

    friend ostream& operator<<(ostream& os, const P& p) {
        return os << p.x << " " << p.y;
    }
};

int main() {
    int n; scanf("%d", &n);
    set<P> s;                             // 自动排序 + 自动去重，只靠 operator<
    for (int i = 0; i < n; i++) {
        long long x, y;
        scanf("%lld %lld", &x, &y);
        s.insert({x, y});
    }
    for (const P& p : s) cout << p << '\n';
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct Matrix {
    int n;
    vector<vector<long long>> a;

    Matrix(int n = 0, bool ident = false) : n(n) {
        a.assign(n, vector<long long>(n, 0));
        if (ident)
            for (int i = 0; i < n; i++) a[i][i] = 1;   // 单位矩阵
    }

    Matrix operator*(const Matrix& o) const {          // ★ 核心
        Matrix r(n);
        for (int i = 0; i < n; i++)
            for (int k = 0; k < n; k++) {
                if (!a[i][k]) continue;                // 跳过 0，稀疏时更快
                long long aik = a[i][k];               // 提取到寄存器
                for (int j = 0; j < n; j++)
                    r.a[i][j] += aik * o.a[k][j];      // 连续访问，缓存友好
            }
        return r;
    }

    friend ostream& operator<<(ostream& os, const Matrix& m) {
        for (int i = 0; i < m.n; i++) {
            for (int j = 0; j < m.n; j++) {
                if (j) os << ' ';
                os << m.a[i][j];
            }
            if (i + 1 < m.n) os << '\n';
        }
        return os;
    }

    bool operator==(const Matrix& o) const {          // 判等：逐元素比较
        if (n != o.n) return false;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if (a[i][j] != o.a[i][j]) return false;
        return true;
    }
};

int main() {
    int n; scanf("%d", &n);
    Matrix A(n), B(n);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) scanf("%lld", &A.a[i][j]);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) scanf("%lld", &B.a[i][j]);

    Matrix C = A * B;             // 一行搞定
    cout << C << endl;

    Matrix I(n, true);            // 单位矩阵：乘法幺元
    cout << "A*I 与 A 相同？" << (A * I == A ? "是" : "否") << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct T {
    int x, y;                                   // 数据成员

    // ── 1. 构造函数：给默认值，兼顾默认构造 ──
    T(int x = 0, int y = 0) : x(x), y(y) {}

    // ── 2. 算术运算符：返回【值】，参数 const 引用 ──
    T operator+(const T& o) const { return T(x + o.x, y + o.y); }
    T operator-(const T& o) const { return T(x - o.x, y - o.y); }
    T operator*(int k)        const { return T(x * k, y * k); }

    // ── 3. 复合赋值：返回【引用】，写 return *this ──
    T& operator+=(const T& o) { x += o.x; y += o.y; return *this; }
    T& operator-=(const T& o) { x -= o.x; y -= o.y; return *this; }

    // ── 4. 一元负号：成员形式不写参数 ──
    T operator-() const { return T(-x, -y); }

    // ── 5. 判等：!= 复用 == ──
    bool operator==(const T& o) const { return x == o.x && y == o.y; }
    bool operator!=(const T& o) const { return !(*this == o); }

    // ── 6. 排序：【严格弱序】，多关键字 != 早返回 ──
    bool operator<(const T& o) const {
        if (x != o.x) return x < o.x;
        return y < o.y;
    }

    // ── 7. 下标（可选）：两个版本 ──
    int&       operator[](int i)       { return i == 0 ? x : y; }
    const int& operator[](int i) const { return i == 0 ? x : y; }

    // ── 8. 函数对象（可选）：operator() 必须 const ──
    bool operator()(const T& a, const T& b) const { return a.x > b.x; }

    // ── 9. 全局形式：左右对称 + 流运算符 ──
    friend T operator*(int k, const T& t) { return T(t.x * k, t.y * k); }

    friend ostream& operator<<(ostream& os, const T& t) {
        return os << "(" << t.x << "," << t.y << ")";
    }
    friend istream& operator>>(istream& is, T& t) {      // ★ 注意没有 const
        return is >> t.x >> t.y;
    }
};

struct Stu { string name; int tot; };

// ── 三个"比较规则"对象 ──
struct ByTotal {                  // 按总分降序
    bool operator()(const Stu& a, const Stu& b) const { return a.tot > b.tot; }
};
struct ByName {                   // 按姓名字典序
    bool operator()(const Stu& a, const Stu& b) const { return a.name < b.name; }
};
struct ByTotalAsc {               // 按总分升序，可直接给小根堆用
    bool operator()(const Stu& a, const Stu& b) const { return a.tot > b.tot; }
};

// ── 使用：同一个容器，三种排序 ──
vector<Stu> v = {...};
sort(v.begin(), v.end(), ByTotal{});
sort(v.begin(), v.end(), ByName{});

priority_queue<Stu, vector<Stu>, ByTotalAsc> pq;     // 总分最小的在堆顶

class Grid {
private:
    int n, m;
    vector<int> data;
public:
    Grid(int n, int m) : n(n), m(m), data(n * m, 0) {}

    // ── 只读版本：const 对象也能用 ──
    const int& operator[](int i) const { return data[i]; }

    // ── 可写版本：支持 g[i] = x ──
    int& operator[](int i) { return data[i]; }

    int at(int i, int j) const { return data[i * m + j]; }
    void set(int i, int j, int v) { data[i * m + j] = v; }
    void fill(int v) { for (int& e : data) e = v; }
};

// 使用：
Grid g(3, 4);
g[5] = 7;                        // 调用可写版本
const Grid& cg = g;
cout << cg[5];                 // 调用只读版本，输出 7

const long long MOD = 1000000007;

struct Mat {
    int n;
    vector<vector<long long>> a;
    Mat(int n = 0, bool I = false) : n(n) {
        a.assign(n, vector<long long>(n, 0));
        if (I) for (int i = 0; i < n; i++) a[i][i] = 1;
    }
    Mat operator*(const Mat& o) const {
        Mat r(n);
        for (int i = 0; i < n; i++)
            for (int k = 0; k < n; k++) {
                if (!a[i][k]) continue;
                for (int j = 0; j < n; j++)
                    r.a[i][j] = (r.a[i][j] + a[i][k] * o.a[k][j]) % MOD;
            }
        return r;
    }
    Mat& operator*=(const Mat& o) { *this = *this * o; return *this; }
};

// ── 矩阵快速幂：与整数快速幂写法一模一样 ──
Mat qpow(Mat base, long long k) {
    Mat res(base.n, true);          // 单位矩阵 = 乘法里的 1
    while (k) {
        if (k & 1) res *= base;      // 原来是 res = mul(res, base)
        base *= base;                // 原来是 base = mul(base, base)
        k >>= 1;
    }
    return res;
}

// ── 对比整数快速幂 ──
long long qpow(long long base, long long k, long long mod) {
    long long res = 1;
    while (k) {
        if (k & 1) res = res * base % mod;
        base = base * base % mod;
        k >>= 1;
    }
    return res;
}