C++ 学习笔记#

extern "C" {
#include "some_c_library.h"
}

int a;               // 未初始化，值未定义！
int b = 10;          // C 风格
int c(20);            // 构造函数风格
int d{30};            // 列表初始化（C++11，推荐）
auto e = 40;          // 自动类型推导

uint8_t a = 0b11001010;  // C++14 二进制字面量
a & 0xFF    // 按位与：掩码提取
a | 0x01    // 按位或：设置某位
a ^ 0x01    // 按位异或：翻转某位
a << 2      // 左移：乘 4
a >> 2      // 右移：除 4

if (ptr != nullptr && ptr->size() > 0)  // ptr 为空时不会访问 ptr->size()

if (score >= 90)
{
    grade = 'A';
}
else if (score >= 80)
{
    grade = 'B';
}
else
{
    grade = 'C';
}

if (auto it = map.find(key); it != map.end())
{
    std::cout << "Found: " << it->second << std::endl;
}
// it 在这里不可用——限制作用域减少 bug

switch (errorCode)
{
    case 0:
        std::cout << "OK";
        break;  // 不加 break 会穿透
    default:
        std::cout << "Unknown";
        break;
}

while (condition) { doSomething(); }

for (int i = 0; i < 10; ++i) { /* ... */ }

// 范围 for（C++11）
for (const auto& item : container) { /* 只读，零拷贝 */ }
for (auto& item : container) { /* 可修改 */ }

void byValue(int x);           // 值传递：拷贝
void byRef(int& x);            // 引用传递：可修改原值
void byConstRef(const int& x); // const 引用：只读不拷贝（黄金参数类型）
void byPtr(int* x);            // 指针传递

void log(const std::string& msg, int level = 0, bool timestamp = true);
void print(int x);
void print(double x);  // 重载：同名不同参数

inline int square(int x) { return x * x; }

std::optional<std::string> findUser(int id)
{
    if (id == 1) return "Alice";
    return std::nullopt;
}

static std::optional<std::string> readText(const std::string& path);
static std::optional<FileInfo> getFileInfo(const std::string& path);

int x = 42;
int* p = &x;     // p 存储 x 的地址
std::cout << *p;  // 解引用，输出 42
*p = 100;         // 通过指针修改 x

int* p = nullptr;   // C++11 空指针
int* arr = new int[10];
delete[] arr;        // new[] 配 delete[]

// 现代 C++：智能指针替代裸 new/delete
auto sp = std::make_shared<int>(42);  // 自动释放

std::string a = "hello";
std::string b = std::move(a);  // 资源转移，不拷贝

std::vector<int> v;
v.push_back(1);
v.size();
v.reserve(100);  // 预分配，避免多次扩容

std::vector<int> v1 = {1, 2, 3};  // 列表初始化

std::string s = "Hello";
s += " World";
s.find("World");  // 6

// C++17 string_view：零拷贝字符串视图
std::string_view sv = "Hello World";

std::map<std::string, int> m;         // 红黑树，O(log n)，有序
std::unordered_map<int, std::string> um; // 哈希表，O(1)，无序

// 结构化绑定（C++17）
for (const auto& [key, value] : m) { /* ... */ }

struct Point { double x, y, z; };
Point p{1.0, 2.0, 3.0};

enum class ErrorCode { OK = 0, NOT_FOUND = 1, INVALID = 40 };
ErrorCode code = ErrorCode::NOT_FOUND;

class Student
{
public:
    Student(const std::string& name, int age)
        : m_name(name), m_age(age)  // 成员初始化列表
    {
    }

    std::string getName() const { return m_name; }
    void setAge(int age) { m_age = age; }

private:
    std::string m_name;  // m_ 前缀
    int m_age;
};

class ConfigManager
{
    mutable std::shared_mutex m_mutex;  // const 函数也能锁
public:
    std::string get(const std::string& key) const
    {
        std::shared_lock lock(m_mutex);  // const 函数中锁 mutex
        return m_config[key];
    }
};

static ConfigManager& instance()
{
    static ConfigManager inst;  // C++11 保证线程安全初始化
    return inst;
}

class Widget
{
public:
    Widget() : m_id(0), m_name("default") {}          // 默认构造
    Widget(int id, const std::string& name)            // 参数构造
        : m_id(id), m_name(name) {}
    Widget(const Widget& other)                         // 拷贝构造
        : m_id(other.m_id), m_name(other.m_name) {}
    Widget(Widget&& other) noexcept                     // 移动构造（C++11）
        : m_id(other.m_id), m_name(std::move(other.m_name)) {}
};

// 禁止拷贝
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;

// 使用编译器默认生成的
Widget() = default;
~Widget() = default;

class FileHandler
{
public:
    FileHandler(const std::string& path) : m_file(std::fopen(path.c_str(), "r")) {}
    ~FileHandler() { if (m_file) std::fclose(m_file); }  // 自动释放
private:
    FILE* m_file;
};

ThreadPool(const ThreadPool&) = delete;
ThreadPool& operator=(const ThreadPool&) = delete;

class Shape
{
public:
    virtual double area() const { return 0; }  // 虚函数
    virtual ~Shape() = default;                 // 虚析构！
};

class Circle : public Shape
{
public:
    Circle(double r) : m_radius(r) {}
    double area() const override { return 3.14159 * m_radius * m_radius; }
private:
    double m_radius;
};

Shape* s = new Circle(5.0);
std::cout << s->area();  // 调用 Circle::area() → 78.54
delete s;  // 虚析构确保调用 Circle 的析构函数

class Base
{
public:
    virtual void foo() {}
    virtual void bar() final {}  // final：禁止子类再覆盖
};

class Derived : public Base
{
public:
    void foo() override {}  // override：写错会报错
    // void bar() override;  // 编译错误！bar 是 final
};

template<typename T>
T maxValue(T a, T b)
{
    return (a > b) ? a : b;
}

maxValue(3, 7);           // T=int
maxValue(3.14, 2.71);     // T=double

template<typename T>
class Stack
{
public:
    void push(const T& value) { m_data.push_back(value); }
    T pop() { T v = m_data.back(); m_data.pop_back(); return v; }
    bool empty() const { return m_data.empty(); }
private:
    std::vector<T> m_data;
};

Stack<int> intStack;
Stack<std::string> strStack;

template<typename... Args>
inline std::string format(const std::string& fmt, Args... args)
{
    std::ostringstream oss;
    size_t argIndex = 0;
    size_t pos = 0;

    auto insertArg = [&](auto&& arg)
    {
        std::string placeholder = "{" + std::to_string(argIndex) + "}";
        size_t placeholderPos = fmt.find(placeholder, pos);

        if (placeholderPos != std::string::npos)
        {
            oss << fmt.substr(pos, placeholderPos - pos);
            oss << arg;
            pos = placeholderPos + placeholder.length();
            argIndex++;
        }
    };

    (insertArg(args), ...);  // C++17 折叠表达式
    oss << fmt.substr(pos);

    return oss.str();
}

#include <memory>

auto p = std::make_unique<int>(42);
// 不能拷贝，只能移动
auto p2 = std::move(p);  // p 变 nullptr，p2 拥有对象

auto p1 = std::make_shared<int>(42);
auto p2 = p1;  // 引用计数 +1
p1.use_count();  // 2

// p1, p2 都销毁后，对象才被 delete

auto sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;  // 不增加引用计数

if (auto locked = wp.lock())  // 提升为 shared_ptr
{
    std::cout << *locked << std::endl;  // 42
}

auto add = [](int a, int b) { return a + b; };
add(3, 4);  // 7

// 捕获外部变量
int x = 10;
auto addX = [x](int a) { return a + x; };      // 值捕获
auto addXRef = [&x](int a) { return a + x; };  // 引用捕获
auto captureAll = [=](int a) { return a + x; }; // 值捕获所有
auto captureAllRef = [&](int a) { return a + x; }; // 引用捕获所有

#include <functional>

std::function<int(int, int)> func;

func = [](int a, int b) { return a + b; };  // Lambda
func = std::bind(&MyClass::method, &obj, std::placeholders::_1, std::placeholders::_2);  // 成员函数

int result = func(3, 4);  // 7

std::queue<std::function<void()>> m_tasks;

#include <thread>

void worker(int id)
{
    std::cout << "Thread " << id << " running" << std::endl;
}

std::thread t1(worker, 1);
std::thread t2(worker, 2);

t1.join();  // 等待 t1 完成
t2.join();  // 等待 t2 完成

std::mutex m_mutex;

// 方式1：手动锁（不推荐，可能忘记 unlock）
m_mutex.lock();
sharedData.push_back(42);
m_mutex.unlock();

// 方式2：lock_guard（RAII，推荐）
{
    std::lock_guard<std::mutex> lock(m_mutex);  // 构造时加锁
    sharedData.push_back(42);
}  // 离开作用域自动解锁

// 方式3：unique_lock（更灵活，可配合 condition_variable）
std::unique_lock<std::mutex> lock(m_mutex);
lock.unlock();  // 可以手动解锁
lock.lock();    // 再锁上

std::mutex m_mutex;
std::condition_variable m_condition;
std::queue<Task> m_tasks;
bool m_stop = false;

// 生产者：提交任务
{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_tasks.push(task);
}
m_condition.notify_one();  // 唤醒一个等待的线程

// 消费者：工作线程等待任务
{
    std::unique_lock<std::mutex> lock(m_mutex);
    m_condition.wait(lock, [&] { return !m_tasks.empty() || m_stop; });
    // wait 会自动解锁 m_mutex，被唤醒后重新加锁
    if (m_stop && m_tasks.empty()) return;
    auto task = m_tasks.front();
    m_tasks.pop();
}

std::atomic<bool> m_stop{false};
std::atomic<int> counter{0};

// 无锁操作，线程安全
counter++;           // 原子自增
counter.fetch_add(1); // 显式原子加
m_stop.store(true);  // 原子写
m_stop.load();       // 原子读

#include <future>

// async 启动异步任务
std::future<int> result = std::async(std::launch::async, []
{
    return 42;
});

// 做其他事情...
int value = result.get();  // 阻塞等待结果

template<typename F, typename... Args>
auto submit(F&& f, Args&&... args) -> std::future<typename std::invoke_result<F, Args...>::type>;

#include <filesystem>
namespace fs = std::filesystem;

// 路径操作
fs::path p = "/data/config.ini";
p.parent_path();    // "/data"
p.filename();       // "config.ini"
p.extension();      // ".ini"

// 文件操作
fs::exists(p);             // 是否存在
fs::file_size(p);          // 文件大小
fs::create_directories(p); // 递归创建目录
fs::remove(p);             // 删除文件
fs::rename(src, dst);      // 重命名

// 遍历目录
for (const auto& entry : fs::directory_iterator("/data"))
{
    std::cout << entry.path() << std::endl;
}

// 递归遍历
for (const auto& entry : fs::recursive_directory_iterator("/data"))
{
    if (entry.is_regular_file())
    {
        std::cout << entry.path() << " : " << entry.file_size() << std::endl;
    }
}

// 文本读取
std::ifstream file("data.txt");
std::string content((std::istreambuf_iterator<char>(file)),
                     std::istreambuf_iterator<char>());

// 二进制读取
std::ifstream bin("data.bin", std::ios::binary);
std::vector<uint8_t> data((std::istreambuf_iterator<char>(bin)),
                           std::istreambuf_iterator<char>());

// 写入
std::ofstream out("output.txt");
out << "Hello" << std::endl;

try
{
    if (errorCondition)
    {
        throw std::runtime_error("Something went wrong");
    }
}
catch (const std::runtime_error& e)
{
    std::cerr << "Runtime error: " << e.what() << std::endl;
}
catch (const std::exception& e)
{
    std::cerr << "Standard exception: " << e.what() << std::endl;
}
catch (...)  // 捕获所有异常
{
    std::cerr << "Unknown exception" << std::endl;
}

// StringUtils.h
#pragma once  // 或传统 include guard

#include <string>
#include <vector>

namespace RyB
{
    // 所有函数必须 inline（允许多个翻译单元包含同一定义）
    inline std::vector<std::string> split(const std::string& str, const std::string& delimiter)
    {
        // 实现...
    }

    // 模板函数天然 inline，不需要加 inline 关键字
    template<typename Container>
    inline std::string join(const Container& container, const std::string& delimiter)
    {
        // 实现...
    }
}

// 纯 C++ 模块用 _WIN32
#ifdef _WIN32
    #include <windows.h>
    #include <winsock2.h>
#else
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <unistd.h>
#endif

// Qt 模块用 Q_OS_WIN
#ifdef Q_OS_WIN
    // Windows 特定代码
#else
    // Linux/macOS 特定代码
#endif

// Windows 文件路径可能包含非 ASCII 字符
#ifdef _WIN32
    // Windows 用 UTF-16 宽字符
    FILE* fp = _wfopen(L"data/文件.txt", L"r");
#else
    // Linux 用 UTF-8
    FILE* fp = fopen("data/文件.txt", "r");
#endif

// Allman 风格：左大括号独占一行
void func()
{
    if (condition)
    {
        doSomething();
    }
}

// K&R 风格（RyBOS 不用）
void func() {
    if (condition) {
        doSomething();
    }
}

/**
 * @file StringUtils.h
 * @brief 字符串工具库（Header-only）
 * @author RyB
 * @version 1.0.0
 *
 * 【模块概述】
 * 提供字符串分割、拼接、替换、编码转换等功能。
 *
 * 【使用示例】
 * @code
 * auto parts = RyB::StringUtils::split("a,b,c", ",");
 * @endcode
 */

/**
 * @brief 分割字符串
 * @param str 原始字符串
 * @param delimiter 分隔符
 * @return 分割后的字符串向量
 */
inline std::vector<std::string> split(const std::string& str, const std::string& delimiter);