C++进阶¶

class Point2D{
public:
    static const int DIMENSION = 2;  // 类的常量属性
    static int count;  // 类的静态属性
    int x, y;
    void move(int dx, int dy) {
        x += dx;
        y += dy;
    }
    Point2D(int x = 0, int y = 0) : x(x), y(y)
    {
        count++;
    }  // 构造函数
    ~Point2D() { count--; }  // 析构函数
}

Point2D p(1, 2);  // 创建一个Point2D对象p，x=1, y=2
p.move(5, -3);  // 移动点p，它自己知道怎么动！
cout << Point2D::count << endl;  // 输出类的静态属性

class Node {
public:
    int data;  // 节点数据
    Node* next;  // 指向下一个节点的指针
    Node(int value) : data(value), next(nullptr) {}
    Node& GetThis() const {
        return *this;  // 返回当前对象的引用
    }
};

class Point2D{
    public:
        int x, y;
        Point2D() {} // 默认构造函数，防止覆盖
        Point2D(int _x, int _y){ // 自己写的构造函数
            x = _x;
            y = _y;
        }
        ~Point2D() {} // 自己写的析构函数
};

Point2D(int _x, int _y) : x(_x), y(_y) { ... }

class Foo {
    int* data;
public:
    Foo(const Foo& rhs) : data(new int[*rhs.data]) {} // 构造函数，深拷贝
    Foo& operator=(Foo rhs) {      // 按值接收，已拷贝/移动
        swap(*this, rhs);          // 交换资源
        return *this;
    }
    friend void swap(Foo& a, Foo& b) noexcept { std::swap(a.data, b.data); }
    // noexcept表示这个函数不会抛出异常
};

class BankAccount {
private:
    int balance;  // 私有属性，外部无法直接访问
public:
    BankAccount(int initialBalance) : balance(initialBalance) {}
    void deposit(int amount) {  // 公共方法，允许外部调用
        if (amount > 0) {
            balance += amount;  // 增加余额
        }
    }
    void withdraw(int amount) {  // 公共方法，允许外部调用
        if (amount > 0 && amount <= balance) {
            balance -= amount;  // 减少余额
        }
    }
    int getBalance() const {  // 公共方法，允许外部查询余额
        return balance;  // 返回余额
    }
};

class Shape { public: virtual double area() = 0; };
class Circle : public Shape { ... };

class Circle : public Shape {
private:
    double radius;  // 圆的半径
public:
    Circle(double r) : radius(r) {}  // 构造函数
    double area() override {  // 重写父类的area()方法
        return M_PI * radius * radius;  // 计算圆的面积
    }
    double circumference() {  // 新增方法，计算圆的周长
        return 2 * M_PI * radius;  // 计算圆的周长
    }
};

class Base {
public:
    Base(int value) {
        cout << "Base constructor with value: " << value << endl;
    }  // 带参数的构造函数
    Base(int v1, int v2) {
        cout << "Base constructor with values: " << v1 << ", " << v2 << endl;
    }  // 另一个带参数的构造函数
    Base() {
        cout << "Base default constructor" << endl;
    }  // 默认构造函数
};
class Derived : public Base {
public:
    Derived(int value) : Base(value) {
        cout << "Derived constructor with data: " << value << endl;
    }  // 子类的构造函数，调用父类的带参数构造函数
    Derived(int v1, int v2) : Base(v1, v2) {
        cout << "Derived constructor with data: " << value << endl;
    }  // 另一个子类的构造函数，调用父类的另一个带参数构造函数
    Derived() : Base() {
        cout << "Derived default constructor" << endl;
    }  // 子类的默认构造函数，调用父类的默认构造函数
};

class Derived : public Base {
public:
    using Base::Base;  // 直接继承父类的所有构造函数
};

    class Base;
    class Derived : public Base { ... };  // 错误，Base类未定义

    class Base { ... };
    class Derived : public Base; // 错误，子类的定义必须紧跟类体

Shape* shape = new Circle();  // 创建一个Circle对象，并将其赋值给Shape指针
shape->area();  // 调用Circle类的area()方法

class MyClass {
private:
    int secret;  // 私有属性
public:
    MyClass(int value) : secret(value) {}  // 构造函数
    friend void revealSecret(const MyClass& obj);  // 声明友元函数
};
void revealSecret(const MyClass& obj) {
    cout << "The secret is: " << obj.secret << endl;  // 访问私有属性
}

template <typename T>
T add(T a, T b) {
    return a + b;  // 返回a和b的和
}
int main() {
    int x = 5, y = 10;
    cout << add(x, y) << endl;  // 调用add函数，输出15
    double a = 3.14, b = 2.71;
    cout << add(a, b) << endl;  // 调用add函数，输出5.85

    return 0;
}

template <typename T>
class Box {
public:
    T value;  // 存储一个值
    Box(T v) : value(v) {}  // 构造函数
    T getValue() const { return value; }  // 获取值的方法
};
Box<int> intBox(42);  // 创建一个存储整数的Box对象
Box<double> doubleBox(3.14);  // 创建一个存储双精度浮点数的Box对象

// 这里需提前定义通用模板
template <typename T>
class Box {
public:
    T value;
    Box(T v) : value(v) {}
    T getValue() const { return value; }
};

template <>
class Box<bool> {  // 为bool类型提供特化实现，完全特化
public:
    bool value;
    Box(bool v) : value(v) {}
    void toggle() { value = !value; }  // 特有的方法，切换布尔值
};

template <typename T>
class Box<T*> {  // 为指针类型提供部分特化实现，部分特化
public:
    T* value;
    Box(T* v) : value(v) {}
    T getValue() const { return *value; }  // 解引用指针获取值
};

template <typename T>
class BaseBox {
public:
    T value;
    // 在这里写通用的成员函数和属性
    BaseBox() { /* 构造函数实现 */ }
}

template <typename T>
class Box : public BaseBox<T> {
    // 在这里写针对其他类型的特化实现
    using BaseBox<T>::BaseBox;  // 继承BaseBox的构造函数
};

template <>
class Box<bool> : public BaseBox<bool> {
    // 在这里写针对bool类型的特化实现
    using BaseBox<bool>::BaseBox;  // 继承BaseBox的构造函数
    void toggle() { this->value = !this->value; }  // 特有的方法，切换布尔值
    // 使用this->value来访问BaseBox<bool>中的value属性
};

template <typename T>
class Box {
public:
    T value;
    Box(T v) : value(v) {}
    T getValue() const { return value; }

    // 只有当T满足概念时，才提供toggle方法
    // 下列概念的意思是：T和bool是一样的
    void toggle() requires std::same_as<T, bool> {
        value = !value;  // 切换布尔值
    }
};

Box<bool> boolBox(true);  // 创建一个存储布尔值的Box对象
boolBox.toggle();  // 调用toggle方法，切换布尔值
Box<int> intBox(42);  // 创建一个存储整数的Box对象
// intBox.toggle();  // 编译错误，不满足概念约束

template <int N>
void printTimes(const std::string& str) {
    for (int i = 0; i < N; ++i) {
        std::cout << str << std::endl;  // 输出字符串N次
    }
}
printTimes<3>("Hello");  // 输出"Hello"三次

template <typename... Args>
void printAll(const Args&... args) {
    ((std::cout << ... << args), ...); // 折叠表达式，输出所有参数
    std::cout << std::endl;  // 最终的输出
}
printAll(1, 2.5, "Hello", 'A');  // 输出

template <typename... Args>
double mean(Args... args) {
    return (static_cast<double>(args) + ...) / sizeof...(args); // 计算均值
}
double result = mean(1, 2, 3, 4, 5);  // result = 3.0

template <int N>
int fact(){ return N * fact<N - 1>(); }

template <>
int fact<0>() { return 1; } // 模板特化，处理N=0的基础情况

int main() {
    std::cout << "Factorial of 5: " << fact<5>() << std::endl; // 输出120
    return 0;
}

constexpr int fact(int n) { return n <= 1 ? 1 : n * fact(n - 1); } // 是常量表达式函数

std::vector<int> v = {3,1,4};   // 自动扩容的数组
std::set<int> s = {3,1,4};      // 自动排序的红黑树
std::unordered_map<std::string,int> m;  // 哈希表

for(auto it=v.begin(); it!=v.end(); ++it) cout<<*it<<' ';
// 或者直接：
for(auto x : v) cout<<x<<' '; // auto最应该这么用！

std::sort(v.begin(), v.end()); // 混合高速排序，结合快排、堆排等算法
std::binary_search(v.begin(), v.end(), 4);  // 二分
std::reverse(v.begin(), v.end());        // 原地翻转

std::ios::sync_with_stdio(false); // 关闭C和C++的同步
std::cin.tie(nullptr); // 取消cin和cout的绑定

#include <iostream>
#include <sstream>
using namespace std;

int main() {
    string str = "123 456 789";
    stringstream ss(str);  // 创建字符串流对象
    int a, b, c;
    ss >> a >> b >> c;  // 从字符串流中读取整数
    cout << "a: " << a << ", b: " << b << ", c: " << c << endl;  // 输出结果
    return 0;
}

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main() {
    string line; // 一堆逗号分隔的单词
    while (getline(cin, line)) {  // 从标准输入中读取一行数据
        stringstream ss(line);  // 创建字符串流对象
        string word;
        while (getline(ss, word, ',')) {  // 从字符串流中读取单词
            cout << word << endl;  // 输出单词
        }
    }
    return 0;
}

#include <iostream>
#include <bitset> // 包含bitset的头文件
using namespace std;
int main() {
    bitset<8> b;  // 创建一个8位的位集合，初始值为00000000
    b.set(3);    // 将第3位（从0开始计数）设置为1，变为00001000
    b.flip(1);   // 将第1位取反，变为00001010
    b.reset(3);  // 将第3位重置为0，变为00000010
    cout << b << endl;  // 输出位集合的值
    cout << "Number of set bits: " << b.count() << endl;  // 计算并输出1的个数
    return 0;
}

#include <iostream>
#include <regex>
#include <string>

int main() {
    /*========  1. 正则与待测字符串  ========*/
    // 匹配中国大陆常见手机号格式：XXX-XXX-XXXXX（3-3-5）
    std::regex  pattern(R"((\d{3})-(\d{3})-(\d{5}))");
    std::string good = "123-456-78910";   // 完全匹配
    std::string bad  = "123-456-789ab";   // 最后一段不是数字
    std::string text = "Call me at 123-456-78910 or 987-654-32100.";

    /*========  2. std::regex_match：整串必须完全匹配 ========*/
    bool is_good = std::regex_match(good, pattern);
    bool is_bad  = std::regex_match(bad,  pattern);
    std::cout << std::boolalpha;
    std::cout << "good match : " << is_good << '\n';   // true
    std::cout << "bad  match : " << is_bad  << '\n';   // false

    /*========  3. 取出捕获组 ========*/
    std::smatch m;
    if (std::regex_match(good, m, pattern)) {
        std::cout << "\n捕获组演示：\n";
        std::cout << "整 match : " << m[0] << '\n';     // 123-456-78910
        std::cout << "第1组    : " << m[1] << '\n';     // 123
        std::cout << "第2组    : " << m[2] << '\n';     // 456
        std::cout << "第3组    : " << m[3] << '\n';     // 78910
    }

    /*========  4. std::regex_search：只要子串匹配即可 ========*/
    if (std::regex_search(text, m, pattern)) {
        std::cout << "\nsearch 找到： " << m[0] << '\n'; // 123-456-78910
    }

    /*========  5. std::regex_replace：替换 + 占位符 ========*/
    // 把电话号码换成“区号$1-局号$2-号码$3”的形式
    std::string repl = std::regex_replace(text, pattern,
                                          "区号$1-局号$2-号码$3");
    std::cout << "\nreplace 结果：\n" << repl << '\n';
    // -> Call me at 区号123-局号456-号码78910 or 区号987-局号654-号码32100.

    /*========  6. 常用占位符小结 ========*/
    // $&   整个匹配
    // $n   第 n 个捕获组，n=0 等价于 $&
    // $$   字面量 '$'
    std::string demo = "Price: 199USD";
    std::regex  pr(R"((\d+)(USD))");
    std::cout << "\n占位符演示：\n"
              << std::regex_replace(demo, pr, "$1 $$100") // 199 $100
              << '\n';

    return 0;
}