cpp重学（二）#

1
class Logger {
2
    int level_;
3
public:
4
    Logger& setLevel(int l) {
5
        level_ = l;
6
        return *this;          // 返回自己
7
    }
8
    Logger& setPrefix(const std::string& p) {
9
        prefix_ = p;
10
        return *this;
11
    }
12
};
13

14
Logger log;
15
log.setLevel(2).setPrefix("[app]");   // 链式：一个一个接着调

1
class Circle {
2
    double radius_;
3
public:
4
    double area() const {   // const 成员函数
5
        return 3.14159 * radius_ * radius_;
6
    }
7
};

1
class Counter {
2
    static int total_;          // 静态成员变量：声明
3
    int id_;
4
public:
5
    Counter() : id_(++total_) {}   // 每个对象拿一个递增的编号
6
    static int total() { return total_; }   // 静态成员函数
7
};
8

9
int Counter::total_ = 0;        // 定义 + 初始化（C++17 前必须写）

1
int n = Counter::total();   // 直接用类名调，不需要对象
2
// Counter c; int n = c.total();  // 也能用对象调，但没必要

1
Vector2 operator*(double k, const Vector2& v) {   // 全局
2
    return Vector2(k * v.x_, k * v.y_);
3
}
4
Vector2 operator*(const Vector2& v, double k) {   // 再写一个对称的
5
    return Vector2(v.x_ * k, v.y_ * k);
6
}
7

8
Vector2 r = 2.0 * v;     // 调全局版本
9
Vector2 s = v * 2.0;     // 调对称版本

1
class Point {
2
    int x_, y_;
3
public:
4
    Point(int x, int y) : x_(x), y_(y) {}
5
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {
6
        os << "(" << p.x_ << ", " << p.y_ << ")";
7
        return os;
8
    }
9
};
10

11
Point pt(1, 2);
12
std::cout << pt;         // 输出 (1, 2)

1
class Cache {
2
    mutable int hit_count_ = 0;      // mutable：const 里也能改
3
    int compute() const {
4
        ++hit_count_;                // 合法：hit_count_ 是 mutable
5
        return 42;
6
    }
7
};

1
// 继承：is-a
2
class Car : public Vehicle { ... };      // 车是一种交通工具
3

4
// 组合：has-a
5
class Car {
6
    Engine engine_;                       // 车拥有一个引擎
7
    std::vector<Wheel> wheels_;
8
};

1
class Base {
2
public:
3
    Base() { std::cout << "Base 构造\n"; }
4
};
5

6
class Derived : public Base {
7
public:
8
    Derived() { std::cout << "Derived 构造\n"; }
9
};
10

11
Derived d;   // 输出：
12
// Base 构造
13
// Derived 构造

1
class Derived : public Base {
2
public:
3
    Derived(int x) : Base(x), extra_(x) {}   // 基类构造写在最前面
4
};

1
class Derived : public Base {
2
    Member a_;        // 成员对象
3
    Member b_;
4
public:
5
    Derived() : Base(), a_(), b_() {}
6
};
7

8
// 构造：Base → a_ → b_ → Derived 函数体
9
// 析构：Derived 函数体 → b_ → a_ → Base

1
class Base {
2
public:
3
    virtual void draw(int x) {}
4
};
5

6
class Derived : public Base {
7
public:
8
    void draw(double x) { ... }   // 本意是重写，但参数类型变了！
9
};

1
class Derived : public Base {
2
public:
3
    void draw(double x) override { ... }   // 编译错误：没有可重写的基类函数
4
};

1
class Base {
2
public:
3
    virtual void f(int) {}
4
    virtual void g() const {}
5
    virtual ~Base() {}
6
};
7

8
class Derived : public Base {
9
public:
10
    void f(int) override {}            // 正确：重写 f
11
    void g() const override {}         // 正确：const 也算签名一部分
12
    // void f(double) override {}      // 错误：签名不匹配
13
};

1
class Base {
2
public:
3
    virtual void f() {}
4
};
5

6
class Derived : public Base {
7
public:
8
    void f() final {}          // 1. 函数级：我重写了，但禁止再往下重写
9
};
10

11
// class Sub : public Derived { void f() override {} };  // 错误：f 已 final
12

13

14
class Sealed final {           // 2. 类级：这个类不许被继承
15
};
16

17
// class X : public Sealed {};  // 错误：Sealed 是 final 的

1
class Shape {
2
public:
3
    virtual double area() const = 0;   // 纯虚函数：= 0，不写实现
4
};
5

6
class Circle : public Shape {
7
    double r_;
8
public:
9
    Circle(double r) : r_(r) {}
10
    double area() const override { return 3.14159 * r_ * r_; }   // 必须实现
11
};

1
void print_area(const Shape& s) {       // 参数用抽象类的引用
2
    std::cout << s.area() << "\n";      // 不管具体是 Circle 还是 Square
3
}
4

5
Circle c(5.0);
6
Square sq(3.0);
7
print_area(c);      // 多态：调用各自实现
8
print_area(sq);

1
class Shape {
2
public:
3
    virtual ~Shape() = 0;   // 纯虚析构
4
};
5

6
Shape::~Shape() {}          // 必须给实现！否则链接错误