第 5 章　类与对象

#include <cmath>
#include <iostream>
struct Point {
    double x = 0.0;
    double y = 0.0;
    double dist() const { return std::sqrt(x * x + y * y); }
};
int main() {
    Point p{3.0, 4.0};
    std::cout << p.dist() << '\n';
    return 0;
}

解析　C++ 里 Point p{...} 直接在栈上建对象，不需要 new；const 成员函数承诺不修改对象。

#include <iostream>
class Counter {
public:
    Counter() { ++instances; }
    ~Counter() { --instances; }
    static int count() { return instances; }
private:
    static int instances;
};
int Counter::instances = 0;
int main() {
    Counter a, b, c;
    std::cout << Counter::count() << '\n';   // 3
    { Counter d; }                            // d 在这里析构
    std::cout << Counter::count() << '\n';   // 3
    return 0;
}

解析　析构在对象离开作用域时自动调用——确定性销毁是 C++ 与 Java 最大的不同。

#include <iostream>
#include <vector>
class VecBox {
public:
    std::vector<int> data;
};
int main() {
    VecBox a;
    a.data = {1, 2, 3};
    VecBox b = a;          // 拷贝：b 有自己的 vector
    b.data[0] = 99;        // 改 b 不影响 a
    for (int x : a.data) { std::cout << x << ' '; }
    std::cout << '\n';     // 1 2 3
    return 0;
}

解析　成员都是自管理资源的类型（vector/string）时，默认拷贝就正确——这就是零法则。

#include <iostream>
#include <vector>
// 好的版本：用 vector 代替裸指针（零法则）
class GoodBox {
public:
    std::vector<int> data;
};
int main() {
    GoodBox a;
    a.data.push_back(7);
    GoodBox b = a;      // 深拷贝，安全
    std::cout << b.data[0] << '\n';
    return 0;
}
// 坏的版本（自己敲一遍再删掉）：
// class BadBox {
// public:
//     int* p;
//     BadBox() : p(new int(0)) { }
//     ~BadBox() { delete p; }   // 拷贝后两个对象共享 p，析构两次 = 崩溃
// };

解析　含裸指针的类默认拷贝是浅拷贝，两个对象析构时双重释放。解法：零法则（用 vector）或五法则（写深拷贝）。

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
struct Student {
    std::string name;
    int score;
    bool operator<(const Student& o) const { return score > o.score; }
};
int main() {
    std::vector<Student> v(3);
    for (int i = 0; i < 3; ++i) { std::cin >> v[i].name >> v[i].score; }
    std::sort(v.begin(), v.end());
    for (const auto& s : v) { std::cout << s.name << ' ' << s.score << '\n'; }
    return 0;
}

解析　有 operator< 就能直接排序；注意比较器必须是严格弱序（相等返回 false）。

#include <iomanip>
#include <iostream>
#include <memory>
#include <vector>
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
};
class Circle : public Shape {
public:
    explicit Circle(double r) : r_(r) { }
    double area() const override { return 3.14159265 * r_ * r_; }
private:
    double r_;
};
class Square : public Shape {
public:
    explicit Square(double side) : side_(side) { }
    double area() const override { return side_ * side_; }
private:
    double side_;
};
int main() {
    double r, side;
    std::cin >> r >> side;
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(r));
    shapes.push_back(std::make_unique<Square>(side));
    std::cout << std::fixed << std::setprecision(2);
    for (const auto& s : shapes) { std::cout << s->area() << '\n'; }
    return 0;
}

解析　多态基类必须有虚析构；多态必须通过指针/引用使用，不能按值。

#include <cstddef>
#include <iostream>
#include <stdexcept>

class IntArray {
public:
    explicit IntArray(std::size_t n)
        : size_(n), data_(n > 0 ? new int[n]{} : nullptr) { }

    IntArray(const IntArray& other)                  // 拷贝构造：深拷贝
        : size_(other.size_), data_(other.size_ > 0 ? new int[other.size_]{} : nullptr) {
        for (std::size_t i = 0; i < size_; ++i) { data_[i] = other.data_[i]; }
    }

    IntArray& operator=(const IntArray& other) {     // 拷贝赋值
        if (this == &other) { return *this; }         // 自赋值
        int* fresh = other.size_ > 0 ? new int[other.size_]{} : nullptr;
        for (std::size_t i = 0; i < other.size_; ++i) { fresh[i] = other.data_[i]; }
        delete[] data_;                               // 新内存准备好再释放旧的
        data_ = fresh;
        size_ = other.size_;
        return *this;                                 // 支持 c = b = a
    }

    ~IntArray() { delete[] data_; }

    std::size_t size() const { return size_; }

    int& at(std::size_t i) {
        if (i >= size_) { throw std::out_of_range("IntArray::at"); }
        return data_[i];
    }
    int at(std::size_t i) const {
        if (i >= size_) { throw std::out_of_range("IntArray::at"); }
        return data_[i];
    }

private:
    std::size_t size_ = 0;
    int* data_ = nullptr;
};

int main() {
    int n{};
    std::cin >> n;
    IntArray a(static_cast<std::size_t>(n));
    for (int i = 0; i < n; ++i) { std::cin >> a.at(static_cast<std::size_t>(i)); }

    IntArray b = a;          // 拷贝构造
    IntArray c(1);
    c = b = a;               // 链式赋值
    b.at(0) = 100;           // 改 b 不影响 a、c

    auto print = [](const char* tag, const IntArray& v) {
        std::cout << tag << ':';
        for (std::size_t i = 0; i < v.size(); ++i) { std::cout << ' ' << v.at(i); }
        std::cout << '\n';
    };
    print("a", a);
    print("b", b);
    print("c", c);

    try { a.at(99); }
    catch (const std::out_of_range& e) { std::cout << "caught: " << e.what() << '\n'; }
    return 0;
}

解析　拷贝赋值三条纪律：处理自赋值、先分配后释放、返回 *this。写完用 -fsanitize=address,undefined 跑一遍，确认没有 double free。