类的概念 与 简单应用

// ── 写法一：struct（默认 public，简洁）──
struct PointA {
    int x, y;                       // 默认就是 public
    void print() { cout << x << "," << y; }
};

// ── 写法二：class（默认 private，必须显式公开）──
class PointB {
    int x, y;                       // 默认 private！外部不可访问
public:
    void set(int a, int b) { x = a; y = b; }
    void print() { cout << x << "," << y; }
};

int main() {
    PointA a;
    a.x = 3; a.y = 4;              // ✅ 可访问
    a.print();                      // 3,4

    PointB b;
    // b.x = 3;                     // ❌ 编译错误：'x' is private
    b.set(3, 4);                  // ✅ 通过公开接口修改
    b.print();                      // 3,4
    return 0;
}

class Counter {
private:
    long long cnt;                  // 外部不能直接改，避免被误清零
public:
    Counter() { cnt = 0; }           // 构造函数：自动初始化为 0

    void add(long long v) {
        if (v < 0) return;          // ✅ 可以在这里加入校验，保护不变式
        cnt += v;
    }
    long long get() const { return cnt; }   // 只读访问器
    void reset() { cnt = 0; }
};

int main() {
    Counter c;
    c.add(5);                       // 通过接口修改
    c.add(-100);                    // 被接口里的校验拦下，不生效
    cout << c.get() << endl;          // 5
    // c.cnt = 0;                  // ❌ 编译错误：private
    return 0;
}

class Vec {
public:
    double x, y;

    // ① 默认构造函数（无参数）：Vec v; 时调用
    Vec() { x = 0; y = 0; }

    // ② 带参数的构造函数：Vec v(3, 4); 时调用
    Vec(double a, double b) { x = a; y = b; }

    // ③ 初始化列表（推荐写法）：在进入函数体前就完成初始化
    // Vec(double a, double b) : x(a), y(b) {}

    // ④ 默认参数形式（可同时替代前两种）
    // Vec(double a = 0, double b = 0) : x(a), y(b) {}

    double len2() { return x * x + y * y; }
};

int main() {
    Vec a;              // 调用默认构造 → (0,0)
    Vec b(3, 4);        // 调用带参构造 → (3,4)
    Vec c = Vec(1, 2);    // 同样是带参构造
    Vec d[3];            // 数组：3 个元素都调用默认构造
    cout << b.len2() << endl;   // 25
    return 0;
}

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

class Tracer {
    string name;
public:
    Tracer(string n) : name(n) { cout << "构造 " << name << endl; }
    ~Tracer()                  { cout << "析构 " << name << endl; }
};

void work() {
    Tracer t("函数内的对象");      // 进入函数时构造
    cout << "  ...干活中..." << endl;
}                                  // 离开函数作用域 → 自动析构

int main() {
    Tracer a("main 里的 a");
    work();
    {
        Tracer b("内层花括号里的 b");
    }                              // 出花括号 → b 被析构
    cout << "main 即将结束" << endl;
    return 0;
}                                  // main 结束 → a 最后析构

class Point {
    int x, y;
public:
    // 用途①：参数与成员同名时，用 this-> 明确指定成员
    void set(int x, int y) {
        this->x = x;                 // 左边是成员，右边是参数
        this->y = y;
    }

    // 用途②：返回自身引用，支持链式调用
    Point& move(int dx, int dy) {
        x += dx; y += dy;
        return *this;               // 返回当前对象本身
    }

    void print() const { cout << x << "," << y << endl; }
};

int main() {
    Point p;
    p.set(1, 2);
    p.move(3, 0).move(0, 4).move(1, 1);   // 链式调用
    p.print();                        // 5,7
    return 0;
}

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

class Fraction {
private:
    long long num, den;              // 分子、分母（不变式：den > 0 且已约分）

    void reduce() {                  // 私有工具：只在类内用，外面看不到
        if (den < 0) { num = -num; den = -den; }   // 统一把负号放分子
        long long g = __gcd(abs(num), den);
        num /= g; den /= g;
    }
public:
    Fraction(long long n = 0, long long d = 1) : num(n), den(d) {
        reduce();                    // 构造即约分：任何对象一出生就合法
    }
    Fraction add(const Fraction& o) const {           // 只读，不改自己
        return Fraction(num * o.den + o.num * den, den * o.den);
    }
    Fraction mul(const Fraction& o) const {
        return Fraction(num * o.num, den * o.den);
    }
    void print() const { printf("%lld/%lld\n", num, den); }
};

int main() {
    Fraction a(1, 2), b(2, 3);
    a.add(b).print();      // 1/2 + 2/3 = 7/6
    a.mul(b).print();      // 1/2 * 2/3 = 1/3
    Fraction c(6, -8);     // 自动整理成 -3/4
    c.print();
    Fraction d;            // 默认构造 = 0/1
    d.print();
    return 0;
}

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

class Date {
private:
    int y, m, d;
    static const int DAYS[13];       // 声明：全类共用一份，不占对象空间
public:
    Date(int y = 1, int m = 1, int d = 1) : y(y), m(m), d(d) {}

    static bool leap(int year) {     // 静态成员函数：没有 this，不依赖具体对象
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }
    int daysInMonth() const {        // 只读：看这个月的天数
        if (m == 2 && leap(y)) return 29;
        return DAYS[m];
    }
    Date nextDay() const {           // 只读：返回一份副本，不动自己
        Date t = *this;
        if (++t.d > t.daysInMonth()) {
            t.d = 1;
            if (++t.m > 12) { t.m = 1; ++t.y; }
        }
        return t;
    }
    void print() const { printf("%04d-%02d-%02d\n", y, m, d); }
};

// ★ 静态成员数组必须在类外再定义一次（C++17 前是硬性规定）
const int Date::DAYS[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};

int main() {
    Date t(2024, 2, 28);
    for (int i = 0; i < 4; i++) { t.print(); t = t.nextDay(); }
    Date u(2023, 12, 31);  u.nextDay().print();   // 2024-01-01
    Date v(1900, 2, 28);   v.nextDay().print();   // 1900-03-01（1900 非闰年）
    return 0;
}

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

class Stack {
private:
    static const int MAXN = 100005;
    int st[MAXN], tp;                 // tp 指向栈顶元素，空栈时 tp = 0
public:
    Stack() : tp(0) {}                // 构造函数：每个新栈都是空的
    void push(int x) { st[++tp] = x; }
    void pop()       { if (tp > 0) --tp; }     // 防御：空栈 pop 不出错
    int  top() const { return st[tp]; }        // 只读接口
    bool empty() const { return tp == 0; }
    int  size()  const { return tp; }
};

int main() {
    Stack s;
    s.push(5); s.push(3); s.push(8);
    printf("top=%d size=%d\n", s.top(), s.size());   // top=8 size=3
    s.pop();
    s.push(1);
    s.pop(); s.pop();
    printf("top=%d size=%d empty=%d\n", s.top(), s.size(), (int)s.empty());
    Stack t;                                          // 第二个栈，与 s 完全独立
    t.push(100);
    printf("t.top=%d s.top=%d\n", t.top(), s.top());
    return 0;
}

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

class DSU {
private:
    vector<int> fa, sz;               // fa 父指针，sz 集合大小
public:
    DSU(int n = 0) { init(n); }      // 构造时就准备好，不怕忘初始化

    void init(int n) {
        fa.resize(n + 1); sz.assign(n + 1, 1);
        for (int i = 0; i <= n; i++) fa[i] = i;   // 每个点自成一个集合
    }
    int find(int x) {                // 路径压缩：顺便把沿途父亲都指向根
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }
    bool merge(int a, int b) {       // 返回 false 说明本来就在同一集合
        int ra = find(a), rb = find(b);
        if (ra == rb) return false;
        if (sz[ra] < sz[rb]) swap(ra, rb);        // 小树挂到大树上
        fa[rb] = ra; sz[ra] += sz[rb];
        return true;
    }
    bool same(int a, int b) { return find(a) == find(b); }
    int  size(int x) { return sz[find(x)]; }       // 某元素所在集合的大小
};

int main() {
    int n = 6;
    DSU d(n);
    d.merge(1, 2); d.merge(2, 3); d.merge(4, 5);
    printf("same(1,3)=%d\n", (int)d.same(1, 3));   // 1
    printf("same(1,4)=%d\n", (int)d.same(1, 4));   // 0
    printf("size(2)=%d\n", d.size(2));             // 3
    d.merge(3, 4);
    printf("same(1,5)=%d size=%d\n", (int)d.same(1, 5), d.size(1));  // 1 5
    return 0;
}

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

class Rect {
private:
    long long x1, y1, x2, y2;      // 统一用 long long，杜绝溢出
public:
    Rect() : x1(0), y1(0), x2(0), y2(0) {}     // 默认构造：零矩形
    Rect(long long a, long long b, long long c, long long d)
        : x1(a), y1(b), x2(c), y2(d) {}
    void input() { scanf("%lld %lld %lld %lld", &x1, &y1, &x2, &y2); }
    long long area() const { return (x2 - x1) * (y2 - y1); }
    bool bigger(const Rect& o) const { return area() > o.area(); }
};

int main() {
    int n; scanf("%d", &n);
    vector<Rect> r(n);                      // 类对象可以放进 vector
    for (int i = 0; i < n; i++) r[i].input();
    long long sum = 0, mx = 0;
    for (int i = 0; i < n; i++) {
        sum += r[i].area();
        if (r[i].area() > mx) mx = r[i].area();
    }
    printf("%lld\n%lld\n", sum, mx);
    return 0;
}

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

class Stu {
private:
    string name;
    int a, b, c, tot;
public:
    void input() {
        cin >> name >> a >> b >> c;
        tot = a + b + c;                  // 总分在类内部算好，外面不用管
    }
    bool isBetter(const Stu& o) const {   // "排在前面"的判定规则
        if (tot != o.tot) return tot > o.tot;   // 总分高的优先
        return name < o.name;                    // 总分相同，名字小的优先
    }
    void print() const { cout << name << ' ' << tot << '\n'; }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; cin >> n;
    vector<Stu> v(n);
    for (int i = 0; i < n; i++) v[i].input();
    sort(v.begin(), v.end(), [](const Stu& a, const Stu& b) {
        return a.isBetter(b);
    });
    for (int i = 0; i < n; i++) v[i].print();
    return 0;
}

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

class DSU {
private:
    vector<int> fa, sz;
public:
    DSU(int n = 0) { init(n); }
    void init(int n) {
        fa.resize(n + 1);
        sz.assign(n + 1, 1);
        for (int i = 0; i <= n; i++) fa[i] = i;
    }
    int find(int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);   // 路径压缩
    }
    void merge(int a, int b) {
        int ra = find(a), rb = find(b);
        if (ra == rb) return;
        if (sz[ra] < sz[rb]) swap(ra, rb);             // 按秩合并
        fa[rb] = ra; sz[ra] += sz[rb];
    }
    bool same(int a, int b) { return find(a) == find(b); }
};

int main() {
    int n, m, q;
    scanf("%d %d %d", &n, &m, &q);
    DSU d(n);
    for (int i = 0; i < m; i++) {
        int u, v; scanf("%d %d", &u, &v);
        d.merge(u, v);                                 // 加边 = 合并
    }
    for (int i = 0; i < q; i++) {
        int a, b; scanf("%d %d", &a, &b);
        puts(d.same(a, b) ? "Yes" : "No");
    }
    return 0;
}

class DSU {
private:
    vector<int> fa, sz;                 // sz：集合大小，用于按秩合并
public:
    DSU(int n = 0) { init(n); }         // 构造即初始化，不怕忘

    void init(int n) {
        fa.resize(n + 1);
        sz.assign(n + 1, 1);
        for (int i = 0; i <= n; i++) fa[i] = i;
    }
    int find(int x) {                    // 路径压缩
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }
    bool merge(int a, int b) {             // 返回是否真的合并了
        int ra = find(a), rb = find(b);
        if (ra == rb) return false;
        if (sz[ra] < sz[rb]) swap(ra, rb);   // 小树挂大树
        fa[rb] = ra; sz[ra] += sz[rb];
        return true;
    }
    bool same(int a, int b) { return find(a) == find(b); }
    int size(int x) { return sz[find(x)]; }
};

class InvTable {
private:
    static const int MOD = 1000000007;
    vector<long long> inv;
public:
    InvTable(int n) {                    // 建对象 = 建表
        inv.assign(n + 1, 0);
        inv[1] = 1;
        for (int i = 2; i <= n; i++)
            inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
    }
    long long operator[](int i) const { return inv[i]; }   // 像数组一样用
};

// 使用：
InvTable iv(1000000);
cout << iv[7] << endl;              // 7 在模 1e9+7 下的逆元

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

class Node {
private:
    int id;
    static int counter;              // 所有 Node 共享一个计数器
public:
    Node() : id(++counter) {}        // 每造一个对象，编号 +1
    int getId() const { return id; }
    static int total() { return counter; }
};

int Node::counter = 0;              // ★ 类外定义（必须有）

int main() {
    Node a, b, c;
    printf("a=%d b=%d c=%d total=%d\n", a.getId(), b.getId(), c.getId(), Node::total());
    return 0;
}

class SegTree {
private:
    int n;
    vector<long long> t;
    void build(int p, int l, int r, const vector<long long>& a) {
        if (l == r) { t[p] = a[l]; return; }
        int mid = (l + r) >> 1;
        build(p << 1, l, mid, a);
        build(p << 1 | 1, mid + 1, r, a);
        t[p] = t[p << 1] + t[p << 1 | 1];
    }
    void modify(int p, int l, int r, int pos, long long v) {
        if (l == r) { t[p] = v; return; }
        int mid = (l + r) >> 1;
        if (pos <= mid) modify(p << 1, l, mid, pos, v);
        else modify(p << 1 | 1, mid + 1, r, pos, v);
        t[p] = t[p << 1] + t[p << 1 | 1];
    }
    long long query(int p, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr) return t[p];
        int mid = (l + r) >> 1; long long res = 0;
        if (ql <= mid) res += query(p << 1, l, mid, ql, qr);
        if (qr > mid)  res += query(p << 1 | 1, mid + 1, r, ql, qr);
        return res;
    }
public:
    SegTree(const vector<long long>& a) {      // 构造时直接建树
        n = (int)a.size() - 1;           // 假定 a 下标从 1 开始
        t.assign(n * 4 + 4, 0);
        build(1, 1, n, a);
    }
    void setPoint(int pos, long long v) { modify(1, 1, n, pos, v); }
    long long rangeSum(int l, int r) { return query(1, 1, n, l, r); }
};