用于大型程序的工具

#include <stdexcept>
#include <iostream>
#include <cmath>
 
void risky(int x) {
    if (x < 0) throw std::invalid_argument("x must be >= 0");
    std::cout << std::sqrt(x) << '\n';
}
 
try {
    risky(-5);
} catch (const std::invalid_argument &e) {
    std::cerr << "Caught: " << e.what() << '\n';  // "Caught: x must be >= 0"
}

struct Widget {
    std::string name;
    Widget(const std::string &n) try : name(n) {
        // 构造函数体
    } catch (const std::exception &e) {
        std::cerr << "ctor failed: " << e.what() << '\n';
        throw;  // 构造函数 try 块的 catch 必须重新抛出或抛另一个异常
    }
};

try {
    call_external_library();
} catch (...) {
    // 1. 记录日志或清理资源
    cleanup_resources();
    // 2. 重新抛出或转成已知类型再抛
    throw std::runtime_error("external library failed");
}

catch (const std::exception &e) {
    log(e.what());
    throw;   // 重新抛出原始异常——保留实际派生类型（可能是 runtime_error 子类）
    // throw e; ← 错误！这会切片——只抛出 exception 部分，丢失派生类信息
}

void safe_swap(std::string &a, std::string &b)
    noexcept(noexcept(a.swap(b))) {
    a.swap(b);  // 异常规格跟随目标类型与实现提供的 swap
}
 
// noexcept 也支持条件形式
template <typename T>
void maybe_noexcept_swap(T &a, T &b)
    noexcept(noexcept(std::swap(a, b))) {  // 外层 noexcept 声明、内层 noexcept 运算符
    std::swap(a, b);
}

// 强保证的赋值操作——copy-and-swap
MyVec &operator=(const MyVec &rhs) {
    MyVec temp(rhs);        // 可能抛异常——但 this 对象还没改！
    swap(*this, temp);      // noexcept——替换成功
    return *this;           // temp 在离开作用域时析构，释放旧资源
}

namespace outer {
namespace middle {
namespace inner {
    int value = 42;
    void helper() {}
} // namespace inner
} // namespace middle
} // namespace outer

// file1.cpp
namespace {
    int counter = 0;     // 只在 file1.cpp 可见
    void init() {}       // 只在 file1.cpp 可见——不会和 file2.cpp 的同名函数冲突
}
 
// file2.cpp
namespace {
    int counter = 100;   // 独立的 counter——和 file1.cpp 的完全无关
}
// 老写法：static int counter = 0;  ← C++ 推荐改用匿名命名空间

namespace lib {
    inline namespace v2 {   // 当前版本设为 inline
        class Feature {};   // 可以直接用 lib::Feature
    }
    namespace v1 {
        class Feature {};   // 必须写 lib::v1::Feature
    }
}
 
lib::Feature f;             // 自动拿到 v2 的 Feature——升级版本不用改调用代码
lib::v1::Feature old;       // 仍然可以显式用旧版本

class Device {
public:
    std::string serial;   // 每台设备的序列号
};
 
class Display : public Device {};  // Display 里有一份 Device
class Sensor : public Device {};   // Sensor 里也有一份 Device
 
class SmartPanel : public Display, public Sensor {};
// SmartPanel 对象里面——有两份 Device 子对象！
 
SmartPanel p;
p.serial;            // ❌ 歧义！是 Display::serial 还是 Sensor::serial？
p.Device::serial;    // ❌ 仍然歧义！有两个 Device 子对象
p.Display::serial;   // ✓ 明确——通过 Display 路径访问的那个 serial

class Device { /* ... */ };
class Display : virtual public Device {};   // Display 虚继承 Device
class Sensor : virtual public Device {};    // Sensor 虚继承 Device
class SmartPanel : public Display, public Sensor {}; // SmartPanel 得到一个共享的 Device

// Display 的构造函数——虽然声明了 virtual Device，但不负责初始化它
Display::Display() : Device() { /* ... */ }  // ← 如果 SmartPanel 是最终类，这行被忽略！
 
// SmartPanel 的构造函数——直接调用虚基类 Device 的构造函数
SmartPanel::SmartPanel()
    : Device()        // ← SmartPanel 负责直接初始化虚基类！
    , Display()
    , Sensor()
{ }

namespace logparser {
// 自定义异常基类——继承自 std::runtime_error
class ParseError : public std::runtime_error {
public:
    explicit ParseError(const std::string &msg)
        : std::runtime_error("logparser: " + msg) {}
};
 
// 字段数量不对
class FieldCountError : public ParseError {
public:
    explicit FieldCountError(int expected, int actual)
        : ParseError("expected " + std::to_string(expected)
                     + " fields, got " + std::to_string(actual)) {}
};
 
// 时间格式非法
class TimeFormatError : public ParseError {
public:
    explicit TimeFormatError(const std::string &raw)
        : ParseError("invalid time format: " + raw) {}
};
} // namespace logparser

namespace logparser {
 
// 虚基类：所有日志都有时间戳
class Timestamped {
public:
    std::string time;
    virtual ~Timestamped() = default;
};
 
// 级别也是虚基类——和 Timestamped 平级
class Leveled {
public:
    std::string level;    // INFO / WARN / ERROR
    virtual ~Leveled() = default;
};
 
// 具体日志类型——虚继承保证 hierarchy 中只有一份 Timestamped
class NetworkLog : virtual public Timestamped, virtual public Leveled {
public:
    int latency_ms = 0;
};
 
class AppLog : virtual public Timestamped, virtual public Leveled {
public:
    std::string module;
};
 
} // namespace logparser

namespace logparser {
 
// 主解析函数：逐字段解析一行日志，可能抛出 ParseError
std::unique_ptr<AppLog> parse_app_line(const std::string &line) {
    auto fields = split(line, ',');          // 按逗号拆字段
    if (fields.size() != 3)
        throw FieldCountError(3, fields.size()); // 抛出——调用方决定是否捕获
 
    if (!is_valid_time(fields[0]))
        throw TimeFormatError(fields[0]);
 
    std::unique_ptr<AppLog> entry(new AppLog); // C++11 所有权立即交给 unique_ptr
    entry->time = fields[0];
    entry->level = fields[1];
    entry->module = fields[2];
    return entry;  // 成功——unique_ptr 的所有权转移给调用方
}
 
} // namespace logparser

int main() {
    try {
        auto entry = logparser::parse_app_line(
            "2024-05-17 14:30:22,ERROR,auth");
        process(entry);
    }
    catch (const logparser::TimeFormatError &e) {
        std::cerr << "Time parse failed: " << e.what() << '\n';
    }
    catch (const logparser::ParseError &e) {
        std::cerr << "Parse failed: " << e.what() << '\n';
    }
    catch (const std::exception &e) {
        std::cerr << "Unexpected: " << e.what() << '\n';
        throw;  // 未知异常原样往上抛——不吞
    }
}