C++ Primer 第18章:用于大型程序的工具

C++ Primer 第18章:用于大型程序的工具


18.1 异常处理

18.1.1 抛出异常

复制代码
// throw_exceptions.cpp -- 抛出异常
#include <iostream>
#include <stdexcept>
#include <string>
​
// 异常对象在 throw 时被拷贝
// 异常对象的类型决定哪个 catch 子句被选中
​
class MyException : public std::runtime_error
{
public:
    MyException(const std::string& msg, int code)
        : std::runtime_error(msg), errorCode_(code) {}
​
    int code() const { return errorCode_; }
​
private:
    int errorCode_;
};
​
void level3()
{
    // throw 表达式:创建异常对象并抛出
    throw MyException("level3发生错误", 404);
}
​
void level2()
{
    try
    {
        level3();
    }
    catch (MyException& e)
    {
        std::cout << "level2捕获并重新抛出:" << e.what() << std::endl;
        throw;   // 重新抛出当前异常(保持原始类型)
        // throw e;   // ⚠️ 这会切割异常对象!
    }
}
​
int main()
{
    using namespace std;
​
    // ===== 基本异常处理 =====
    try
    {
        level2();
    }
    catch (const MyException& e)
    {
        cout << "main捕获:" << e.what()
             << " 错误码:" << e.code() << endl;
    }
    catch (const runtime_error& e)
    {
        cout << "runtime_error:" << e.what() << endl;
    }
    catch (const exception& e)
    {
        cout << "exception:" << e.what() << endl;
    }
    catch (...)
    {
        cout << "未知异常" << endl;
    }
​
    // ===== 异常与析构函数 =====
    // 析构函数不应该抛出异常!
    // 如果析构函数抛出异常,且此时已有异常在传播,程序会调用 terminate()
​
    return 0;
}

18.1.2 栈展开与异常安全

复制代码
// stack_unwinding.cpp -- 栈展开
#include <iostream>
#include <memory>
#include <string>
​
class Resource
{
public:
    Resource(const std::string& name) : name_(name)
    {
        std::cout << "[获取] " << name_ << std::endl;
    }
    ~Resource()
    {
        std::cout << "[释放] " << name_ << std::endl;
    }
​
private:
    std::string name_;
};
​
// ===== 异常安全的三个级别 =====
// 1. 基本保证:异常后对象处于有效状态(可能改变)
// 2. 强保证:异常后对象状态不变(事务性)
// 3. 不抛出保证:操作不会抛出异常(noexcept)
​
class SafeVector
{
private:
    std::vector<int> data_;
​
public:
    // 强保证:使用拷贝并交换
    void push_back_safe(int val)
    {
        auto temp = data_;   // 拷贝
        temp.push_back(val); // 可能抛出
        data_.swap(temp);    // noexcept,不会失败
    }
​
    // 基本保证:可能部分完成
    void push_back_basic(int val)
    {
        data_.push_back(val);   // 可能抛出
    }
};
​
void demonstrateUnwinding()
{
    Resource r1("资源A");
    {
        Resource r2("资源B");
        throw std::runtime_error("测试异常");
        // r2 在这里自动析构(栈展开)
    }
    // r1 在这里自动析构(栈展开)
}
​
int main()
{
    using namespace std;
​
    cout << "===== 栈展开演示 =====" << endl;
    try
    {
        demonstrateUnwinding();
    }
    catch (const exception& e)
    {
        cout << "捕获:" << e.what() << endl;
    }
​
    // ===== RAII 保证异常安全 =====
    cout << "\n===== RAII 异常安全 =====" << endl;
    try
    {
        auto p1 = make_unique<Resource>("智能指针资源1");
        auto p2 = make_unique<Resource>("智能指针资源2");
        throw runtime_error("RAII测试");
        // p1, p2 自动释放,无内存泄漏
    }
    catch (const exception& e)
    {
        cout << "捕获:" << e.what() << endl;
    }
​
    return 0;
}

18.1.3 noexcept 异常说明

复制代码
// noexcept_demo.cpp -- noexcept
#include <iostream>
#include <vector>
#include <stdexcept>
​
// noexcept:承诺函数不抛出异常
// 如果抛出,程序调用 std::terminate()
​
// 析构函数默认是 noexcept
class MyClass
{
public:
    ~MyClass() noexcept   // 析构函数应该是 noexcept
    {
        // 不应该在析构函数中抛出异常
    }
​
    // 移动操作应该是 noexcept(让容器使用移动而非拷贝)
    MyClass(MyClass&&) noexcept = default;
    MyClass& operator=(MyClass&&) noexcept = default;
};
​
// noexcept 说明符
void safeFunc() noexcept
{
    // 不会抛出异常
}
​
// noexcept 运算符:检查表达式是否会抛出
template <typename T>
void swap(T& a, T& b) noexcept(noexcept(T(std::move(a))))
{
    T temp = std::move(a);
    a = std::move(b);
    b = std::move(temp);
}
​
int main()
{
    using namespace std;
​
    // 检查函数是否 noexcept
    cout << boolalpha;
    cout << "safeFunc是否noexcept:" << noexcept(safeFunc()) << endl;
​
    // vector 在扩容时:
    // 如果移动构造是 noexcept,使用移动(高效)
    // 否则使用拷贝(安全但低效)
    vector<MyClass> v;
    v.push_back(MyClass{});   // 使用移动(因为移动构造是noexcept)
​
    return 0;
}

18.1.4 异常类层次结构

复制代码
// exception_hierarchy.cpp -- 异常类层次
#include <iostream>
#include <stdexcept>
#include <string>
​
/*
std::exception
├── std::bad_alloc          new 失败
├── std::bad_cast           dynamic_cast 失败
├── std::bad_typeid         typeid 失败
├── std::bad_exception
└── std::logic_error        逻辑错误(可预防)
    ├── std::domain_error   定义域错误
    ├── std::invalid_argument 无效参数
    ├── std::length_error   长度错误
    └── std::out_of_range   越界
└── std::runtime_error      运行时错误(难以预防)
    ├── std::overflow_error  上溢
    ├── std::underflow_error 下溢
    └── std::range_error     范围错误
*/
​
// 自定义异常层次
class AppException : public std::exception
{
protected:
    std::string message_;
    int         code_;
​
public:
    AppException(const std::string& msg, int code)
        : message_(msg), code_(code) {}
​
    const char* what() const noexcept override
    {
        return message_.c_str();
    }
​
    int code() const { return code_; }
};
​
class DatabaseException : public AppException
{
public:
    DatabaseException(const std::string& msg)
        : AppException("数据库错误: " + msg, 1001) {}
};
​
class NetworkException : public AppException
{
public:
    NetworkException(const std::string& msg)
        : AppException("网络错误: " + msg, 2001) {}
};
​
class ValidationException : public AppException
{
private:
    std::string field_;
​
public:
    ValidationException(const std::string& field, const std::string& msg)
        : AppException("验证错误[" + field + "]: " + msg, 3001),
          field_(field) {}
​
    const std::string& field() const { return field_; }
};
​
void processRequest(int type)
{
    switch (type)
    {
        case 1: throw DatabaseException("连接超时");
        case 2: throw NetworkException("DNS解析失败");
        case 3: throw ValidationException("email", "格式无效");
        default: throw AppException("未知错误", 9999);
    }
}
​
int main()
{
    using namespace std;
​
    for (int i = 1; i <= 4; i++)
    {
        try
        {
            processRequest(i);
        }
        catch (const ValidationException& e)
        {
            cout << "[验证] " << e.what()
                 << " 字段:" << e.field() << endl;
        }
        catch (const DatabaseException& e)
        {
            cout << "[数据库] " << e.what()
                 << " 代码:" << e.code() << endl;
        }
        catch (const NetworkException& e)
        {
            cout << "[网络] " << e.what() << endl;
        }
        catch (const AppException& e)
        {
            cout << "[应用] " << e.what()
                 << " 代码:" << e.code() << endl;
        }
    }
​
    return 0;
}

18.2 命名空间

18.2.1 命名空间基础

复制代码
// namespace_basics.cpp -- 命名空间基础
#include <iostream>
#include <string>
​
// ===== 定义命名空间 =====
namespace cplusplus_primer
{
    class Sales_data { /* ... */ };
    Sales_data operator+(const Sales_data&, const Sales_data&);
​
    class Query { /* ... */ };
    class Query_base { /* ... */ };
}
​
// ===== 命名空间可以不连续(开放性)=====
namespace cplusplus_primer
{
    // 继续添加成员
    class QueryResult { /* ... */ };
}
​
// ===== 嵌套命名空间 =====
namespace outer
{
    int x = 1;
​
    namespace inner
    {
        int x = 2;   // 与 outer::x 不冲突
​
        void show()
        {
            std::cout << "inner::x = " << x << std::endl;
            std::cout << "outer::x = " << outer::x << std::endl;
        }
    }
}
​
// ===== 内联命名空间(C++11)=====
// 内联命名空间的成员可以直接被外层命名空间访问
namespace FifthEd
{
    inline namespace FifthEdV1
    {
        void func() { std::cout << "FifthEdV1::func" << std::endl; }
    }
​
    namespace FifthEdV2
    {
        void func() { std::cout << "FifthEdV2::func" << std::endl; }
    }
}
​
// ===== 匿名命名空间 =====
// 等价于 static,只在本文件可见
namespace
{
    int localVar = 42;   // 只在本文件可见
    void localFunc() { std::cout << "局部函数" << std::endl; }
}
​
int main()
{
    using namespace std;
​
    // 使用嵌套命名空间
    outer::inner::show();
​
    // 内联命名空间
    FifthEd::func();           // 调用 FifthEdV1::func(内联)
    FifthEd::FifthEdV1::func(); // 显式指定
    FifthEd::FifthEdV2::func(); // 显式指定
​
    // 匿名命名空间
    cout << localVar << endl;
    localFunc();
​
    return 0;
}

18.2.2 using 声明和 using 指示

复制代码
// using_demo.cpp -- using声明和指示
#include <iostream>
#include <string>
​
namespace Lib1
{
    int x = 1;
    void func() { std::cout << "Lib1::func" << std::endl; }
    class MyClass { public: void show() { std::cout << "Lib1::MyClass" << std::endl; } };
}
​
namespace Lib2
{
    int x = 2;
    void func() { std::cout << "Lib2::func" << std::endl; }
}
​
void demoUsingDeclaration()
{
    // using 声明:引入单个名字
    using Lib1::func;
    using Lib1::MyClass;
​
    func();   // Lib1::func
    MyClass obj;
    obj.show();
​
    // using Lib2::func;   // ❌ 错误!func已经被Lib1::func占用
}
​
void demoUsingDirective()
{
    // using 指示:引入整个命名空间
    using namespace Lib1;
    using namespace Lib2;
​
    // x;   // ❌ 二义性!Lib1::x 还是 Lib2::x?
    Lib1::x;   // 必须显式指定
    Lib2::x;
​
    // func();   // ❌ 二义性!
    Lib1::func();
    Lib2::func();
}
​
// ===== 命名空间与函数重载 =====
namespace NS
{
    void print(int i)    { std::cout << "NS::print(int) " << i << std::endl; }
    void print(double d) { std::cout << "NS::print(double) " << d << std::endl; }
}
​
void print(std::string s) { std::cout << "::print(string) " << s << std::endl; }
​
int main()
{
    using namespace std;
​
    demoUsingDeclaration();
    demoUsingDirective();
​
    // 实参依赖查找(ADL/Koenig查找)
    // 调用函数时,编译器会在实参类型所在的命名空间中查找
    using NS::print;
    print(42);       // NS::print(int)
    print(3.14);     // NS::print(double)
    print(string("hello"));  // ::print(string)
​
    return 0;
}

18.2.3 命名空间与类

复制代码
// namespace_class.cpp -- 命名空间与类
#include <iostream>
#include <string>
​
namespace MyLib
{
    // 类定义在命名空间中
    class Screen
    {
    public:
        using pos = std::string::size_type;
​
        Screen(pos ht, pos wd, char c)
            : height(ht), width(wd), contents(ht * wd, c) {}
​
        char get() const { return contents[cursor]; }
        Screen& move(pos r, pos c);
​
    private:
        pos         cursor = 0;
        pos         height = 0, width = 0;
        std::string contents;
    };
​
    // 在命名空间外定义成员函数
    Screen& Screen::move(pos r, pos c)
    {
        cursor = r * width + c;
        return *this;
    }
​
    // 友元函数自动成为命名空间的成员
    class Window_mgr
    {
    public:
        void clear(Screen& s)
        {
            s.contents = std::string(s.height * s.width, ' ');
        }
    };
}
​
int main()
{
    MyLib::Screen s(5, 5, 'X');
    s.move(2, 2);
    std::cout << s.get() << std::endl;
​
    return 0;
}

18.3 多重继承与虚继承

18.3.1 多重继承

复制代码
// multiple_inheritance.cpp -- 多重继承
#include <iostream>
#include <string>
​
class ZooAnimal
{
public:
    ZooAnimal() { std::cout << "[ZooAnimal构造]" << std::endl; }
    virtual ~ZooAnimal() { std::cout << "[ZooAnimal析构]" << std::endl; }
​
    virtual std::string name() const { return "ZooAnimal"; }
    void breathe() const { std::cout << "呼吸" << std::endl; }
};
​
class Endangered
{
public:
    Endangered() { std::cout << "[Endangered构造]" << std::endl; }
    virtual ~Endangered() { std::cout << "[Endangered析构]" << std::endl; }
​
    virtual std::string status() const { return "濒危"; }
    void protect() const { std::cout << "保护中" << std::endl; }
};
​
// 多重继承
class Panda : public ZooAnimal, public Endangered
{
public:
    Panda() { std::cout << "[Panda构造]" << std::endl; }
    ~Panda() { std::cout << "[Panda析构]" << std::endl; }
​
    std::string name()   const override { return "大熊猫"; }
    std::string status() const override { return "极度濒危"; }
​
    void eat() const { std::cout << "吃竹子" << std::endl; }
};
​
int main()
{
    using namespace std;
​
    cout << "===== 构造顺序 =====" << endl;
    Panda p;
​
    cout << "\n===== 使用 =====" << endl;
    p.breathe();   // ZooAnimal 的成员
    p.protect();   // Endangered 的成员
    p.eat();       // Panda 自己的成员
​
    cout << "名字:" << p.name() << endl;
    cout << "状态:" << p.status() << endl;
​
    // 多态
    ZooAnimal* za = &p;
    Endangered* en = &p;
​
    cout << "\n通过基类指针:" << endl;
    cout << za->name() << endl;   // 大熊猫(虚函数)
    cout << en->status() << endl; // 极度濒危(虚函数)
​
    cout << "\n===== 析构顺序(逆序)=====" << endl;
    return 0;
}

18.3.2 虚继承

复制代码
// virtual_inheritance.cpp -- 虚继承
#include <iostream>
#include <string>

// 菱形继承问题:
//        Animal
//       /      \
//    Tiger    Lion
//       \      /
//       Liger(狮虎兽)
// 没有虚继承时,Liger 会有两份 Animal 的数据!

class Animal
{
public:
    Animal(const std::string& name) : name_(name)
    {
        std::cout << "[Animal构造] " << name_ << std::endl;
    }
    virtual ~Animal() { std::cout << "[Animal析构]" << std::endl; }

    virtual std::string sound() const { return "..."; }
    std::string name() const { return name_; }

protected:
    std::string name_;
};

// 虚继承:解决菱形继承问题
class Tiger : virtual public Animal
{
public:
    Tiger(const std::string& name) : Animal(name)
    {
        std::cout << "[Tiger构造]" << std::endl;
    }
    ~Tiger() { std::cout << "[Tiger析构]" << std::endl; }

    std::string sound() const override { return "吼"; }
    void hunt() const { std::cout << "老虎在狩猎" << std::endl; }
};

class Lion : virtual public Animal
{
public:
    Lion(const std::string& name) : Animal(name)
    {
        std::cout << "[Lion构造]" << std::endl;
    }
    ~Lion() { std::cout << "[Lion析构]" << std::endl; }

    std::string sound() const override { return "咆哮"; }
    void roar() const { std::cout << "狮子在咆哮" << std::endl; }
};

// 最终派生类必须显式初始化虚基类
class Liger : public Tiger, public Lion
{
public:
    // 必须显式调用 Animal 的构造函数
    Liger(const std::string& name)
        : Animal(name),   // 虚基类构造函数
          Tiger(name),
          Lion(name)
    {
        std::cout << "[Liger构造]" << std::endl;
    }
    ~Liger() { std::cout << "[Liger析构]" << std::endl; }

    // 必须重写 sound(),否则二义性
    std::string sound() const override { return "特殊叫声"; }
};

int main()
{
    using namespace std;

    cout << "===== 虚继承 =====" << endl;
    Liger liger("狮虎兽");

    cout << "\n===== 使用 =====" << endl;
    cout << "名字:" << liger.name() << endl;   // 只有一份 name_
    cout << "叫声:" << liger.sound() << endl;
    liger.hunt();
    liger.roar();

    // 只有一份 Animal 数据
    Animal* ap = &liger;
    cout << "通过Animal*:" << ap->name() << endl;

    cout << "\n===== 析构 =====" << endl;
    return 0;
}

18.3.3 虚继承中的构造顺序

复制代码
// virtual_inheritance_order.cpp -- 虚继承构造顺序
#include <iostream>

class Base
{
public:
    Base(int v) : val(v)
    {
        std::cout << "Base(" << v << ")" << std::endl;
    }
    int val;
};

class D1 : virtual public Base
{
public:
    D1(int v) : Base(v)
    {
        std::cout << "D1(" << v << ")" << std::endl;
    }
};

class D2 : virtual public Base
{
public:
    D2(int v) : Base(v)
    {
        std::cout << "D2(" << v << ")" << std::endl;
    }
};

class Final : public D1, public D2
{
public:
    // 虚基类由最终派生类初始化
    // D1 和 D2 中的 Base(v) 被忽略
    Final(int v1, int v2, int vb)
        : Base(vb),   // 虚基类
          D1(v1),
          D2(v2)
    {
        std::cout << "Final" << std::endl;
    }
};

int main()
{
    // 构造顺序:
    // 1. 虚基类(Base)
    // 2. 非虚基类(D1, D2,按声明顺序)
    // 3. 最终派生类(Final)
    Final f(1, 2, 100);
    std::cout << "val = " << f.val << std::endl;   // 100(虚基类的值)

    return 0;
}

18.4 综合示例:大型程序框架

复制代码
// large_program_framework.cpp -- 综合示例
#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <map>
#include <functional>
#include <stdexcept>
#include <sstream>

// ===== 命名空间组织代码 =====
namespace Framework
{
    // ===== 异常层次 =====
    class FrameworkException : public std::exception
    {
    protected:
        std::string message_;
        int         code_;

    public:
        FrameworkException(const std::string& msg, int code)
            : message_(msg), code_(code) {}

        const char* what() const noexcept override
        {
            return message_.c_str();
        }
        int code() const { return code_; }
    };

    class ConfigException : public FrameworkException
    {
    public:
        ConfigException(const std::string& key)
            : FrameworkException("配置项不存在: " + key, 1001) {}
    };

    class ServiceException : public FrameworkException
    {
    public:
        ServiceException(const std::string& service)
            : FrameworkException("服务不可用: " + service, 2001) {}
    };

    // ===== 配置管理 =====
    class Config
    {
    private:
        std::map<std::string, std::string> data_;

    public:
        void set(const std::string& key, const std::string& val)
        {
            data_[key] = val;
        }

        const std::string& get(const std::string& key) const
        {
            auto it = data_.find(key);
            if (it == data_.end())
                throw ConfigException(key);
            return it->second;
        }

        template <typename T>
        T getAs(const std::string& key) const
        {
            const std::string& val = get(key);
            std::istringstream iss(val);
            T result;
            if (!(iss >> result))
                throw FrameworkException("类型转换失败: " + key, 1002);
            return result;
        }

        bool has(const std::string& key) const
        {
            return data_.count(key) > 0;
        }
    };

    // ===== 服务接口(抽象基类)=====
    class IService
    {
    public:
        virtual ~IService() = default;
        virtual void start()   = 0;
        virtual void stop()    = 0;
        virtual bool isRunning() const = 0;
        virtual std::string name() const = 0;
    };

    // ===== 具体服务 =====
    class DatabaseService : public IService
    {
    private:
        bool running_ = false;
        std::string host_;
        int         port_;

    public:
        DatabaseService(const Config& cfg)
        {
            host_ = cfg.get("db.host");
            port_ = cfg.getAs<int>("db.port");
        }

        void start() override
        {
            std::cout << "[DB] 连接到 " << host_ << ":" << port_ << std::endl;
            running_ = true;
        }

        void stop() override
        {
            std::cout << "[DB] 断开连接" << std::endl;
            running_ = false;
        }

        bool isRunning() const override { return running_; }
        std::string name() const override { return "DatabaseService"; }

        void query(const std::string& sql) const
        {
            if (!running_)
                throw ServiceException(name());
            std::cout << "[DB] 执行:" << sql << std::endl;
        }
    };

    class CacheService : public IService
    {
    private:
        bool running_ = false;
        std::map<std::string, std::string> cache_;

    public:
        void start() override
        {
            std::cout << "[Cache] 启动缓存服务" << std::endl;
            running_ = true;
        }

        void stop() override
        {
            std::cout << "[Cache] 停止缓存服务" << std::endl;
            cache_.clear();
            running_ = false;
        }

        bool isRunning() const override { return running_; }
        std::string name() const override { return "CacheService"; }

        void set(const std::string& key, const std::string& val)
        {
            if (!running_) throw ServiceException(name());
            cache_[key] = val;
        }

        std::string get(const std::string& key) const
        {
            if (!running_) throw ServiceException(name());
            auto it = cache_.find(key);
            if (it == cache_.end())
                throw FrameworkException("缓存未命中: " + key, 3001);
            return it->second;
        }
    };

    // ===== 服务容器 =====
    class ServiceContainer
    {
    private:
        std::map<std::string, std::shared_ptr<IService>> services_;

    public:
        template <typename T, typename... Args>
        std::shared_ptr<T> registerService(Args&&... args)
        {
            auto service = std::make_shared<T>(std::forward<Args>(args)...);
            services_[service->name()] = service;
            return service;
        }

        template <typename T>
        std::shared_ptr<T> getService(const std::string& name) const
        {
            auto it = services_.find(name);
            if (it == services_.end())
                throw ServiceException(name);
            return std::dynamic_pointer_cast<T>(it->second);
        }

        void startAll()
        {
            for (auto& [name, service] : services_)
            {
                try
                {
                    service->start();
                    std::cout << name << " 启动成功" << std::endl;
                }
                catch (const std::exception& e)
                {
                    std::cerr << name << " 启动失败:" << e.what() << std::endl;
                }
            }
        }

        void stopAll()
        {
            for (auto& [name, service] : services_)
            {
                try
                {
                    if (service->isRunning())
                        service->stop();
                }
                catch (const std::exception& e)
                {
                    std::cerr << name << " 停止失败:" << e.what() << std::endl;
                }
            }
        }
    };

}   // namespace Framework

int main()
{
    using namespace std;
    using namespace Framework;

    // ===== 配置 =====
    Config cfg;
    cfg.set("db.host", "localhost");
    cfg.set("db.port", "5432");
    cfg.set("app.name", "MyApp");

    cout << "===== 配置读取 =====" << endl;
    try
    {
        cout << "db.host = " << cfg.get("db.host") << endl;
        cout << "db.port = " << cfg.getAs<int>("db.port") << endl;
        cout << cfg.get("missing.key") << endl;   // 抛出异常
    }
    catch (const ConfigException& e)
    {
        cout << "配置错误:" << e.what() << endl;
    }

    // ===== 服务容器 =====
    cout << "\n===== 服务启动 =====" << endl;
    ServiceContainer container;

    auto db    = container.registerService<DatabaseService>(cfg);
    auto cache = container.registerService<CacheService>();

    container.startAll();

    // ===== 使用服务 =====
    cout << "\n===== 使用服务 =====" << endl;
    try
    {
        db->query("SELECT * FROM users");
        cache->set("user:1", "Alice");
        cout << "缓存:" << cache->get("user:1") << endl;
        cout << "缓存:" << cache->get("user:999") << endl;   // 未命中
    }
    catch (const ServiceException& e)
    {
        cout << "服务错误:" << e.what() << endl;
    }
    catch (const FrameworkException& e)
    {
        cout << "框架错误[" << e.code() << "]:" << e.what() << endl;
    }

    // ===== 停止服务 =====
    cout << "\n===== 服务停止 =====" << endl;
    container.stopAll();

    return 0;
}

📝 第18章知识点总结

知识点 核心要点
异常抛出 throw 创建异常对象,throw; 重新抛出(保持原始类型)
栈展开 异常传播时自动调用局部对象析构函数,RAII保证资源释放
异常安全 基本保证(有效状态)、强保证(状态不变)、不抛出保证(noexcept)
noexcept 承诺不抛出,析构函数和移动操作应标记noexcept
异常类层次 继承 std::exception,重写 what(),按从具体到抽象的顺序catch
命名空间 解决命名冲突,namespace name { } 定义,:: 访问
开放命名空间 命名空间可以分多次定义,成员累积
内联命名空间 C++11,成员可直接被外层命名空间访问,用于版本管理
匿名命名空间 替代 static,限制文件内可见性
using 声明 引入单个名字,冲突时报错
using 指示 引入整个命名空间,可能导致二义性
ADL(实参依赖查找) 在实参类型所在命名空间中查找函数
多重继承 继承多个基类,构造顺序按声明顺序,析构逆序
虚继承 解决菱形继承,虚基类只有一份,最终派生类负责初始化
虚继承构造顺序 先虚基类,再非虚基类(按声明顺序),最后派生类
相关推荐
ComPDFKit5 小时前
RAG 回答只显示 PDF 文件名?用 Python 保留引用页码
开发语言·python·pdf·rag
FRing035 小时前
vue3干货总结2(vue3生命周期、父子通信、模版引用、provide和inject)
开发语言·前端·vue.js·vue3
琳少_7 小时前
java程序开发笔记
java·开发语言·数据库·笔记
七夜zippoe8 小时前
Agent 告警设计:分级告警、智能降噪与值班排班
开发语言·ai·agent·告警·智能降噪·值班排班
无忧.芙桃8 小时前
C++语言原理与实践(二十三):哈希表的实现
c++·链表·哈希算法·散列表·哈希表
严肃小白兔9 小时前
PHP 8.6 正式发布:部分函数应用、原生 I/O 轮询与新特性实战解析
开发语言·php
郝学胜-神的一滴10 小时前
Effective Python 条款36:优雅拼装迭代器与生成器
开发语言·数据结构·人工智能·python·numpy·scikit-learn
AvocadoZeroOneOI11 小时前
B4500 [GESP202603 三级] 凯撒密码 详细解题报告
c++·算法
wuyk55511 小时前
Python办公自动化-第04讲-批量新建Excel
开发语言·python·excel
code2cat12 小时前
【随笔】Java客户端选了HTTP/3,怎样知道请求实际走了哪个版本
java·开发语言·http