第十七章 用于大型程序的工具

        C++ 解决问题规模多样，对复杂问题尤其需用异常处理、命名空间和多重继承增强代码管理、库整合和概念表达，以适应大规模编程对错误处理、模块组合及高级功能设计的高要求。

17.1. 异常处理

        异常处理允许C++程序中不同部分通过抛出和捕获异常来通信和处理错误。当检测到无法本地解决的问题时，抛出异常，并由能够处理该问题的代码捕获。

异常抛出：

        在检测到错误（如ISBN不匹配）时，使用throw关键字抛出异常对象（如std::runtime_error），包含错误信息。

异常捕获：

        在可能抛出异常的代码周围使用try块，并在其后用catch块捕获特定类型的异常。捕获后，可以处理错误（如打印错误信息）。

异常处理要点：

        理解异常抛出时控制流的转移，捕获时如何匹配异常类型，以及异常对象如何传递错误信息。

17.1.1. 抛出类类型的异常

        异常处理是C++中一种强大的错误管理机制，通过抛出和捕获异常对象来实现。

异常抛出与捕获

        异常通过throw关键字抛出对象，对象的类型决定哪个catch块将被激活。

        catch块匹配离抛出点最近且能处理该异常类型的代码。

        异常对象由编译器管理，保证在异常处理期间可访问，并在处理完毕后销毁。

异常对象的传递

        抛出表达式的结果被复制来创建异常对象，因此被抛出的类型必须可复制。

        抛出数组或函数时，它们会被自动转换为指向首元素的指针或函数指针。

异常与继承

        抛出表达式时，异常对象的类型由静态编译时类型决定。

        如果抛出的是继承体系中的对象，则异常对象的类型将是该对象的静态类型。

异常与指针

        抛出指针时要特别小心，因为必须确保在捕获异常时指针所指向的对象仍然存在。

        抛出指向局部对象的指针通常是不安全的，因为局部对象在函数返回后将被销毁。

        抛出指针时，应确保处理代码中的对象生命周期覆盖异常处理的整个过程。

// 抛出异常  
void mightThrow() {  
    throw std::runtime_error("An error occurred");  
}  
  
// 捕获异常  
void handleError() {  
    try {  
        mightThrow();  //抛出异常
    } catch (const std::runtime_error& e) {  //捕获异常
        std::cerr << "Caught exception: " << e.what() << std::endl;  
    }  
}  
  
// 错误示例：抛出指向局部对象的指针  
void badThrow() {  
    int* localPtr = new int(10); // 注意：这里使用了new，但在实际场景中应避免这样  
    throw localPtr; // 危险：localPtr指向的对象将在函数返回后被销毁  
    // 注意：这里为了示例简化了内存管理，实际中应使用智能指针或避免抛出指针  
}  
  
// 正确处理指针的方式（尽管通常不推荐抛出指针）  
void safePointerThrow() {  
    std::shared_ptr<int> safePtr = std::make_shared<int>(10);  
    throw safePtr; // 抛出智能指针更安全，因为智能指针会管理内存  
    // 注意：即便如此，捕获时仍需谨慎处理智能指针的生命周期  
}

17.1.2. 栈展开

        C++中异常处理的机制，包括栈展开、局部对象的析构、析构函数不应抛出异常、以及构造函数中的异常处理。

异常处理流程

        抛出异常：当throw语句执行时，当前函数的执行被暂停，开始查找匹配的catch子句。

        栈展开：如果在当前函数中找到了匹配的catch子句，则处理异常，程序正常执行；否则，退出当前函数（释放局部对象并调用析构函数），继续在调用者函数中查找。这个过程一直持续到找到匹配的catch子句或程序终止。

        局部对象析构：在栈展开期间，会释放局部对象的内存并调用它们的析构函数（如果对象是类类型）。这确保了资源的正确释放。

析构函数与异常

        析构函数内部应该避免抛出异常。如果在析构函数中抛出异常且未被捕获，程序将调用std::terminate()，通常导致程序非正常退出。

构造函数与异常

        构造函数内部可以抛出异常，但如果对象只是部分构造，则已构造的成员需要被适当撤销。

#include <iostream>  
#include <stdexcept>  
  
class Resource {  
public:  
    Resource() { std::cout << "Resource constructed\n"; }  
    ~Resource() noexcept { std::cout << "Resource destructed\n"; }  //noexcept声明的函数如果抛出异常,会直接调用terminated函数终止程序
    void riskyOperation() { throw std::runtime_error("Failed"); }  
};  
  
void mightFail() {  
    Resource res;  
    res.riskyOperation(); // 可能抛出异常  
    // 如果riskyOperation抛出异常，则res的析构函数将被调用  
}  
  
int main() {  
    try {  
        mightFail();  
    } catch (const std::runtime_error& e) {  
        std::cerr << "Caught exception: " << e.what() << std::endl;  
    }  
    // 如果mightFail中没有异常，程序将正常结束  
    // 如果mightFail中抛出异常并被捕获，则异常处理代码将执行  
    // 无论如何，Resource的析构函数都将被调用  
    return 0;  
}

17.1.3. 捕获异常

异常处理中的catch子句

        在C++中，catch子句用于捕获并处理异常。每个catch子句后面跟着一个异常说明符，它定义了该子句能够捕获的异常类型。

异常说明符

        类型：必须是完全类型，不能是前向声明。

        形参名：可选，用于在catch块中引用异常对象。

复制与引用：

        如果不是引用，则异常对象会被复制到catch形参中。

        如果是引用，则catch形参直接引用异常对象。

匹配规则

严格匹配：

        除了少数特殊情况外（如非const到const的转换、派生类到基类的转换、数组和函数指针的转换），异常类型和catch说明符类型必须完全匹配。

第一个匹配：

        找到的第一个可以处理该异常的catch子句会被选中，因此派生类型的catch子句必须出现在基类类型之前。

#include <iostream>  
#include <exception>  
using namespace std;  
  
class BaseException : public exception {  
public:  
    const char* what() const noexcept override {  
        return "BaseException";  
    }  
};  
  
class DerivedException : public BaseException {  
public:  
    const char* what() const noexcept override {  
        return "DerivedException";  
    }  
};  
  
int main() {  
    try {  
        throw DerivedException(); // 抛出派生类异常  
    } catch (DerivedException& e) {  
        cout << "Caught DerivedException: " << e.what() << endl;  
    } catch (BaseException& e) {  
        cout << "Caught BaseException: " << e.what() << endl; // 这行不会被执行  
    }  
    return 0;  
}

17.1.4. 重新抛出

重新抛出异常

        在catch块中，如果你决定当前处理逻辑不足以完全处理异常，你可以通过简单的throw;语句重新抛出当前捕获的异常。这个空throw语句会重新抛出当前正在处理的异常对象，而不是一个新的异常对象。

只能在catch块或其调用的函数中使用：throw;只能在catch块内或其直接调用的函数内部使用。

动态类型保持：当异常被重新抛出时，即使catch块的形参是基类类型，实际抛出的异常对象仍然保持其原始的动态类型（即派生类型，如果有的话）。

引用与非引用形参

引用形参：如果catch块的形参是通过引用捕获的，那么对形参的任何修改都会反映到原始异常对象上。当重新抛出异常时，这些修改会一起被传播。

非引用形参：如果catch块的形参不是通过引用捕获的，那么形参是原始异常对象的一个副本。对形参的修改不会影响原始异常对象，重新抛出的异常对象将保持不变。

17.1.5. 捕获所有异常的处理代码

捕获所有异常的 catch 子句

        在C++中，可以使用catch(...)子句来捕获任何类型的异常。这个子句是一个通配符，可以匹配任何被抛出的异常。这在你不确定可能会抛出哪些类型的异常时非常有用。

try {  
    // 可能抛出异常的代码  
} catch (...) {  
    // 放置处理未知异常的代码  
}

与重新抛出表达式结合使用

        有时，即使函数无法完全处理被抛出的异常，它也可能需要在退出前执行一些清理工作或其他必要的操作。在这些情况下，你可以在catch(...)子句中完成这些工作，并使用throw;语句重新抛出捕获的异常，以便让上层调用者有机会处理它。

void manip() {  
    try {  
        // 执行可能抛出异常的操作  
    } catch (...) {  
        // 在这里执行清理工作或记录日志  
        // ...  
        // 然后重新抛出异常  
        throw;  //throw后跟空的内容，代表正在处理的异常直接抛出
    }  
}

catch(...) 子句的位置

        catch(...)子句可以单独使用，作为唯一的catch子句来捕获所有异常。它也可以与其他具体的catch子句结合使用，但在这种情况下，它必须是最后一个catch子句，因为一旦匹配到catch(...)，后面的任何catch子句都将不会被考虑。

try {  
    // 可能抛出多种异常的代码  
} catch (const std::runtime_error& e) {  
    // 处理特定类型的异常  
} catch (...) {  
    // 处理所有其他类型的异常  
    // 必须是最后一个catch子句  
}

17.1.6. 函数测试块与构造函数

        在C++中，如果构造函数需要处理来自其初始化列表中的异常，那么必须将整个构造函数定义为一个函数try块。这通过在成员初始化列表之前放置try关键字，并在构造函数体周围使用复合语句（即大括号{}）来完成。这样做之后，紧随其后的catch子句可以捕获并处理在初始化列表或构造函数体内抛出的任何异常。

        注意，下面将构造函数写为函数测试块的做法其实不符合C++标准，这里仅供学习。

        关键字 try 出现在成员初始化列表之前，并且测试块的复合语句包围了构造函数的函数体。catch 子句既可以处理从成员初始化列表中抛出的异常，也可以处理从构造函数函数体中抛出的异常。

template <class T>  
class Handle {  
public:  
    Handle(T *p) try   
        : ptr(p), use(new size_t(1)) // 成员初始化列表  
    catch (const std::bad_alloc &e) {  
        // 处理内存分配失败的代码  
        handle_out_of_memory(e);  
        // 注意：这里通常不会继续构造对象，因此可能还需要一些额外逻辑来确保对象状态正确  
    } {  
        // 构造函数体（可以为空，因为所有初始化都已在初始化列表中完成）  
    }  
  
private:  
    T* ptr;  
    size_t* use;  
  
    void handle_out_of_memory(const std::bad_alloc &e) {  
        // 处理内存不足的逻辑，如记录错误、释放已分配的资源等  
        std::cerr << "Memory allocation failed: " << e.what() << std::endl;  
        // 注意：在实际应用中，这里可能还需要执行一些清理工作  
        // 但由于构造函数已经失败，对象的状态可能是未定义的  
    }  
};

        C++标准不允许在构造函数声明中直接使用try来包围成员初始化列表，这些初始化操作在构造函数体执行之前完成，并且它们并不属于构造函数体的一部分。

17.1.7. 异常类层次

 17.1.8. 自动资源释放

        在C++中，异常安全是编程时需要关注的重要方面。当异常发生时，确保已分配的资源得到适当释放是非常重要的。为了实现这一目标，C++鼓励使用RAII（Resource Acquisition Is Initialization）技术，即通过类来管理资源的分配和释放。

RAII 技术概述

RAII：

        资源获取即初始化。它是一种在C++中管理资源（如动态分配的内存、文件句柄、锁等）的常用技术。

核心思想：

        通过类的构造函数来分配资源，并通过析构函数来释放资源。这样，无论函数是正常返回还是由于异常而退出，只要类的实例超出了作用域，其析构函数就会自动被调用，从而释放资源。

class Resource {  
public:  
    Resource(parameters p) : r(allocate(p)) {} // 构造函数分配资源  
    ~Resource() { release(r); } // 析构函数释放资源  
  
    // 可能还需要定义拷贝构造函数和赋值运算符  
  
private:  
    resource_type* r; // 被管理的资源  
  
    // 辅助函数  
    static resource_type* allocate(parameters p); // 分配资源  
    static void release(resource_type* p); // 释放资源  
};  
  
// 使用 Resource 类的示例  
void fcn() {  
    Resource res(args); // 分配资源  
    // 可能会抛出异常的代码  
    // ...  
} // 当函数退出时（无论是否因为异常），res 的析构函数都会自动调用，释放资源

 17.1.9. auto_ptr 类

        auto_ptr 是 C++ 标准库中的一个模板类，用于管理动态分配的对象，确保在发生异常时也能安全地释放资源。然而，需要注意的是，auto_ptr 在 C++11 及以后的版本中已被废弃，并被 std::unique_ptr 取代，因为 auto_ptr 的复制和赋值行为可能导致意外的资源释放。

auto_ptr 的基本特性

模板类：接受一个类型参数，用于指定 auto_ptr 可以管理的对象类型。

异常安全：在函数退出或发生异常时，自动释放所管理的资源。

所有权：每个 auto_ptr 对象“拥有”一个动态分配的对象，当 auto_ptr 被销毁或重置时，其管理的对象也会被删除。

复制和赋值：复制或赋值 auto_ptr 会导致所有权转移，原 auto_ptr 变为未绑定状态。

#include <memory> // 包含 auto_ptr 的头文件（注意：在 C++11 及以后应使用 unique_ptr）  
#include <string>  
  
void f() {  
    // 使用 auto_ptr 管理动态分配的 int  
    std::auto_ptr<int> ap(new int(42));  
    // 如果这里发生异常，ap 的析构函数将自动调用，释放 int 对象  
}  
  
// 使用 auto_ptr 管理动态分配的 string  
std::auto_ptr<std::string> ap1(new std::string("Brontosaurus"));  
*ap1 = "TRex"; // 修改 ap1 指向的 string 对象  
if (!ap1->empty()) { // 调用 string 对象的成员函数  
    // ...  
}  
  
// 复制 auto_ptr，所有权转移  
std::auto_ptr<std::string> ap2(ap1); // ap1 现在未绑定，ap2 拥有原对象  
  
// 赋值 auto_ptr，同样导致所有权转移  
std::auto_ptr<std::string> ap3(new std::string("Pterodactyl"));  
ap3 = ap2; // ap3 现在拥有 ap2 的对象，ap2 未绑定  
  
// 重置 auto_ptr  
if (!ap3.get()) { // 检查 ap3 是否未绑定  
    ap3.reset(new std::string("New Dinosaur")); // 绑定新对象  
}

注意事项

不要将 auto_ptr 存储在标准容器中：

        因为复制和赋值会改变原 auto_ptr 的状态，这违反了容器对元素的要求。

避免使用 auto_ptr：

        在 C++11 及以后的版本中，应使用 std::unique_ptr 替代 auto_ptr，因为 unique_ptr 提供了更安全、更灵活的资源管理功能。

不能直接赋值指针给 auto_ptr：

        必须使用 reset 方法来改变 auto_ptr 管理的对象。

17.1.10. 异常说明

        异常说明是C++中用于声明函数可能抛出的异常类型的一种机制。它帮助调用者了解函数的安全性，即函数在出错时是否会抛出异常，以及会抛出哪些类型的异常。

1. 异常说明的基本形式

非空异常说明：指定函数可能抛出的异常类型列表。

void recoup(int) throw(runtime_error);  // recoup 可能抛出 runtime_error 或其派生类型

空异常说明：表明函数不会抛出任何异常。

void no_problem() throw();  // no_problem 承诺不抛出任何异常

2. 违反异常说明

        如果函数抛出了未在异常说明中列出的异常，将调用 std::unexpected() 函数，默认情况下将导致程序终止。

void f() throw() { throw exception(); }  // 违反异常说明，将调用 unexpected

3. 异常说明的用途

确定函数不抛出异常：这对于编写异常安全的代码很有帮助，因为调用者知道不需要处理异常。

编译器优化：如果编译器知道函数不会抛出异常，它可能会进行更激进的优化。

4. 成员函数的异常说明

        成员函数的异常说明跟在形参表之后。对于const成员函数，异常说明跟在const限定符之后。

class MyClass {  
public:  
    void myFunction() const throw(runtime_error);  // const成员函数  
};

5. 析构函数的异常说明

        析构函数应尽可能不抛出异常，因为它们在异常处理过程中被调用，可能会掩盖原始异常。

        标准库中的许多类（如std::string）保证它们的析构函数不会抛出异常。

6. 异常说明与虚函数

        派生类中重写的虚函数可以有不同的异常说明，但派生类的异常说明必须至少与基类中的一样严格或更严格。

class Base {  
public:  
    virtual void func() throw(runtime_error);  
};  
  
class Derived : public Base {  
public:  
    virtual void func() throw();  // 正确，更严格  
    // virtual void func() throw(std::underflow_error);  // 错误，更宽松  
};

17.1.11. 函数指针的异常说明

异常说明与函数指针

        在C++中，函数的异常说明是函数类型的一部分，它指定了该函数可能抛出的异常类型。当这些函数被赋值给函数指针时，指针的异常说明必须满足一定的条件。

规则概述

赋值兼容性：

        如果函数A的异常说明比函数B的更严格（即A能抛出的异常类型集是B的子集），则可以将函数B的地址赋给指向函数A的函数指针。

严格性：

        如果目标函数指针的异常说明比源函数的更严格（即限制更多），则赋值是合法的。

无异常函数：

        如果一个函数指针被声明为不抛出任何异常（throw()），则只能指向那些同样不抛出任何异常的函数。

        具有严格的异常说明的指针可以兼容异常声明宽松的指针。

        无异常函数指针只能指向无异常函数。

17.2. 命名空间

17.2.1. 命名空间的定义

命名空间的定义与作用

定义：

        命名空间是一个作用域，用于封装一组相关的名字（如类名、函数名等），以避免全局命名冲突。

语法：

        以namespace关键字开始，后跟命名空间名称和一对花括号{}，其中包含命名空间的成员声明。

namespace MyNamespace {  
    class MyClass {};  
    void myFunction();  
}

避免命名冲突

        问题：在复杂程序中，尤其是使用多个独立开发的库时，全局作用域中的名字很容易发生冲突。

        解决方案：使用命名空间将不同库或模块中的名字封装起来，从而避免冲突。

使用命名空间中的成员

直接访问：使用命名空间名::成员名的形式直接访问。

MyNamespace::MyClass obj;  
MyNamespace::myFunction();

简化访问：使用using声明或using指令简化对命名空间成员的访问。

using MyNamespace::MyClass;  
MyClass obj; // 现在可以直接使用MyClass  
  
// 或使用using namespace指令  
using namespace MyNamespace;  
MyClass obj;  
myFunction();

命名空间的不连续性

        命名空间可以在多个部分中定义，这些部分可以是分散在多个文件中的。

        所有部分定义的命名空间成员共同构成了该命名空间。

接口与实现的分离

        命名空间的定义也可以像类和函数一样，将接口（声明）和实现（定义）分离到不同的文件中。

// MyNamespace.h    头文件(接口)
namespace MyNamespace {  
    class MyClass {  
    public:  
        MyClass();  
        void myMethod();  
    };  
}

// MyNamespace.cpp   源文件(实现)
#include "MyNamespace.h"  
  
MyNamespace::MyClass::MyClass() {  
    // 构造函数实现  
}  
  
void MyNamespace::MyClass::myMethod() {  
    // 方法实现  
}

//用户代码
#include "MyNamespace.h"  
  
int main() {  
    MyNamespace::MyClass obj;  
    obj.myMethod();  
    return 0;  
}

17.2.2. 嵌套命名空间

嵌套命名空间的概念：

        嵌套命名空间是一个命名空间的内部定义的另一个命名空间，其作用域被限定在外围命名空间内。在嵌套命名空间中定义的成员（如类、函数等）默认只在该命名空间内部可见，外围命名空间之外的代码需要通过限定名（即包含外围命名空间和嵌套命名空间名称的完整路径）来访问这些成员。

用途：

        嵌套命名空间在大型库或项目中特别有用，因为它可以帮助组织和管理代码，防止不同部分之间的命名冲突。

/*嵌套命名空间示例*/
namespace cplusplus_primer {  
    // 第一个嵌套命名空间：定义库的Query部分  
    namespace QueryLib {  
        class Query { /* ... */ };  
        Query operator&(const Query&, const Query&);  
        // ... 其他Query相关的定义  
    }  
  
    // 第二个嵌套命名空间：定义库的Sales_item部分  
    namespace Bookstore {  
        class Item_base { /* ... */ };  
        class Bulk_item : public Item_base { /* ... */ };  
        // ... 其他Bookstore相关的定义  
    }  
}  
  
// 访问嵌套命名空间中的成员  
// 例如，访问QueryLib中的Query类  
cplusplus_primer::QueryLib::Query myQuery;  
  
// 访问Bookstore中的Bulk_item类  
cplusplus_primer::Bookstore::Bulk_item myBulkItem;

17.2.3. 未命名的命名空间

        未命名的命名空间（也称为匿名命名空间）是一个特殊的命名空间，它在定义时没有显式名称。它主要用于限制作用域到单个文件内，避免全局命名冲突。未命名的命名空间中的成员（如变量、类型等）在定义它们的文件内部可直接访问，无需前缀限定，但在该文件外部不可见。

特点：

局部于文件：

        未命名的命名空间定义仅在当前文件内有效，不跨越多个文件。

不连续定义：

        在同一文件内，未命名的命名空间可以分散定义，但所有定义属于同一命名空间。

避免命名冲突：

        与全局作用域隔离，可以在不同文件中定义同名实体而不会冲突。

生命周期：

        其中的变量在程序启动时创建，在程序结束时销毁。

嵌套：

        未命名的命名空间可以嵌套在其他命名空间中，此时需要通过外围命名空间访问。

注意事项：

        在全局作用域中，未命名的命名空间中的成员不能与全局变量等重名，否则会导致命名冲突。

        头文件中定义未命名的命名空间可能会导致包含该头文件的每个文件都拥有独立的命名空间实例，通常不推荐这种做法。

17.2.4. 命名空间成员的使用

        在C++中，使用长命名空间名时，可以通过几种方式简化对命名空间成员的访问。这些方法包括using声明、命名空间别名和using指示。

1. using声明

        using声明允许你在特定作用域内引入一个命名空间中的单个成员，而不需要每次都使用完整的命名空间前缀。这有助于减少代码冗余，同时保持对命名空间的明确引用。

using std::string;  
string s = "Hello"; // 直接使用string，无需std::

2. 命名空间别名

        命名空间别名提供了一种为长命名空间名创建短同义词的方法。这有助于简化对嵌套命名空间成员的访问。

namespace primer = cplusplus_primer;  
primer::QueryLib::Query tq; // 使用别名简化访问

3. using指示

        与using声明不同，using指示会将整个命名空间中的所有名字引入到当前作用域中，这可能导致命名冲突。因此，它通常只在局部作用域（如函数内部）或命名空间的实现文件中使用。

void func() {  
    using namespace std;  
    cout << "Hello, world!" << endl; // 直接使用cout和endl  
}

17.2.5. 类、命名空间和作用域

namespace A {  
    int i;  
    namespace B {  
        int i; // 隐藏A::i  
        int f1() { return i; } // 返回B::i  
    }  
}

namespace A {  
    class C1 {  
        int i; // 隐藏A::i  
        int j;  
    public:  
        C1() : i(0), j(0) {} // 初始化C1::i和C1::j  
        int f1() { return A::k; } // 返回A::k  
    };  
    int k;  
}

std::string s;  
getline(std::cin, s); // 无需std::限定符，因为getline是std::string的接口部分

namespace A {  
    class C {  
        friend void f(const C&); // f成为A的成员  
    };  
}  
  
void f2() {  
    A::C cobj;  
    f(cobj); // 调用A::f，无需A::限定符  
}

namespace NS {  
    void print(int) { /* ... */ }  
    void print(double) { /* ... */ }  
}  
  
void print(const std::string&) { /* ... */ }  
  
using namespace NS; // 引入NS命名空间中的所有成员  
  
void foo() {  
    print(1); // 调用NS::print(int)  
    print(3.14); // 调用NS::print(double)  
    print("Hello"); // 调用全局的print(const std::string&)  
}  
  
// 如果有多个using指示  
namespace AW {  
    void print(int) { /* ... */ }  
}  
  
namespace Primer {  
    void print(double) { /* ... */ }  
}  
  
using namespace AW;  
using namespace Primer;  
  
void bar() {  
    print(1); // 调用AW::print(int)  
    print(3.14); // 调用Primer::print(double)  
}

#include <iostream>  
  
// 定义在命名空间ns中的通用模板  
namespace ns {  
    template<typename T>  
    void print(T value) {  
        std::cout << "General: " << value << std::endl;  
    }  
}  
  
// 显式特化ns::print模板，针对int类型  
// 重新打开命名空间ns并定义特化  
namespace ns {  
    template<>  
    void print<int>(int value) {  
        std::cout << "Specialization for int: " << value << std::endl;  
    }  
}  
  
// 或者，使用命名空间名字限定模板名来定义特化（在命名空间外部）  
// 注意：这种方式通常用于模板特化不直接与原始模板在同一文件或作用域中定义时  
// 但在这个例子中，为了保持精简，我们不会展示这种方式的实际代码，因为它通常涉及更复杂的场景  
  
int main() {  
    ns::print(10); // 调用特化版本  
    ns::print(3.14); // 调用通用模板版本  
    return 0;  
}

class ZooAnimal { /* ... */ };  
class Bear : public ZooAnimal { /* ... */ };  
class Endangered { /* ... */ };  
  
class Panda : public Bear, public Endangered { /* ... */ };

class ZooAnimal {  
public:  
    virtual void print(std::ostream& os) const { /* ... */ }  
    virtual ~ZooAnimal() {}  
};  
  
class Bear : public ZooAnimal {  
public:  
    using ZooAnimal::print;  //using显式声明指定继承ZooAnimal的print
    void print(std::ostream& os) const override { /* Bear-specific print */ }  
    // ...  
};  
  
class Endangered {  
public:  
    void print(std::ostream& os) const { /* Endangered-specific print */ }  
    // ...  
};  
  
class Panda : public Bear, public Endangered {  
public:  
    using Bear::print; // 解决print的二义性，选择Bear的print  
    void fullPrint(std::ostream& os) const {  
        Bear::print(os); // 显式调用Bear的print  
        Endangered::print(os); // 显式调用Endangered的print  
    }  
    // ...  
};  
  
// 使用  
Panda ying_yang;  
ying_yang.print(std::cout); // 调用Bear的print  
ying_yang.fullPrint(std::cout); // 同时调用Bear和Endangered的print

class ios { ... };  
class istream : public virtual ios { ... };  
class ostream : virtual public ios { ... };  
class iostream : public istream, public ostream { ... };

class ZooAnimal { ... };  
class Bear : virtual public ZooAnimal { ... };  
class Raccoon : virtual public ZooAnimal { ... };  
class Panda : public Bear, public Raccoon { ... };  
  
Panda::Panda(std::string name, bool onExhibit)  
    : ZooAnimal(name, onExhibit, "Panda"),  
      Bear(name, onExhibit),  
      Raccoon(name, onExhibit),  
      // 其他成员初始化  
{  
    // 构造函数体  
}

class Character { ... };  
class BookCharacter : public Character { ... };  
class ToyAnimal { ... };  
class Bear : public virtual ZooAnimal { ... };  
class TeddyBear : public BookCharacter, public Bear, public virtual ToyAnimal { ... };  
  
// 构造函数调用次序：  
// ZooAnimal(); // Bear的虚基类  
// ToyAnimal(); // TeddyBear的虚基类  
// Character(); // BookCharacter的非虚基类  
// BookCharacter(); // TeddyBear的非虚基类  
// Bear(); // TeddyBear的非虚基类  
// TeddyBear(); // 最底层派生类  
  
// 析构函数调用次序相反

int x = {5};  
double y{2.75};  
short quar[5]{4, 5, 2, 76, 1};  
int* ar = new int[4]{2, 4, 6, 7};  
  
class Stump {  
public:  
    Stump(int r, double w) : roots(r) {}  
private:  
    int roots;  
    double weight;  
};  
  
Stump si(3, 15.6); // 旧风格  
Stump s2{5, 43.4}; // C++11风格  
Stump s3 = {4, 32.1}; // C++11风格

char c1{1.57e27}; // 编译时错误  
char c2{(459585821)}; // 编译时错误，超出范围  
char c3{66}; // 允许，int-to-char，在范围内  
double c4{66}; // 允许，int-to-double

#include <initializer_list>  
#include <vector>  
  
std::vector<int> v1{1, 2, 3, 4}; // 使用initializer_list  
  
double sum(std::initializer_list<double> il) {  
    double tot = 0;  
    for (auto p = il.begin(); p != il.end(); ++p) tot += *p;  
    return tot;  
}  
  
int main() {  
    double total = sum({2.5, 3.1, 4.0}); // 传递initializer_list  
}

auto x = 10;     // x 是 int 类型  
auto* ptr = &x;  // ptr 是 int* 类型  
auto func = []() { return 1.0; }; // func 是 lambda 表达式对应的函数对象类型

int i = 0;  
decltype(i) j;       // j 是 int 类型   相当于 int j
decltype(i + 0.5) k; // k 是 double 类型 相当于 double k

template<typename T, typename U>  
auto add(T t, U u) -> decltype(t + u) {  
    return t + u;  
}

template<typename T>  
using Vec = std::vector<T>;  
  
Vec<int> intVec; // 相当于 std::vector<int> intVec;  
  
template<typename T>  
using Array12 = std::array<T, 12>;  
  
Array12<double> doubleArray; // 相当于 std::array<double, 12> doubleArray;

int* ptr = nullptr; // 使用 nullptr 表示空指针  
  
// 如果函数接受 int 参数，传递 nullptr 会导致编译错误  
void func(int x) {}  
// func(nullptr); // 编译错误  
func(0); // 编译通过，但不建议这样表示空指针

#include <memory>  
  
std::unique_ptr<int> ptr(new int(10));  
// ... 使用ptr  
// 当ptr离开作用域时，它指向的int对象会被自动删除

#include <memory>  
  
std::shared_ptr<int> ptr1 = std::make_shared<int>(10);  
std::shared_ptr<int> ptr2 = ptr1; // ptr1和ptr2共享所有权  
// ... 使用ptr1和ptr2  
// 当ptr1和ptr2都离开作用域时，int对象才会被删除

#include <iostream>  
  
// 声明一个不会抛出异常的函数  
void safeFunction() noexcept {  
    // 函数体，保证不会抛出异常  
    std::cout << "This function is safe and will not throw." << std::endl;  
}  
  
// 没有使用noexcept的函数，可能抛出异常  
void riskyFunction() {  
    // 函数体，可能包含抛出异常的代码  
    throw std::runtime_error("This function might throw.");  
}  
  
int main() {  
    try {  
        safeFunction(); // 调用安全的函数  
        // riskyFunction(); // 如果取消注释，将引发异常，且由于noexcept的保证，调用者需要处理  
    } catch (const std::exception& e) {  
        std::cout << "Caught an exception: " << e.what() << std::endl;  
    }  
    return 0;  
}

// 传统的C++枚举（非作用域枚举）  
enum Color { RED, GREEN, BLUE };  
  
// C++11作用域枚举（使用class或struct定义）  
enum class NewColor { RED, GREEN, BLUE };  
  
// 使用作用域枚举  
void printColor(NewColor color) {  
    switch (color) {  
        case NewColor::RED:  
            std::cout << "Red" << std::endl;  
            break;  
        case NewColor::GREEN:  
            std::cout << "Green" << std::endl;  
            break;  
        case NewColor::BLUE:  
            std::cout << "Blue" << std::endl;  
            break;  
        default:  
            std::cout << "Unknown color" << std::endl;  
    }  
}  
  
int main() {  
    // 访问作用域枚举成员时必须显式限定  
    printColor(NewColor::RED);  
    // printColor(RED); // 这会编译失败，因为RED不在全局作用域中  
    return 0;  
}

class A {  
public:  
    explicit A(int x) {} // 显式构造函数  
};

class B {  
public:  
    operator int() const { return 42; } // 隐式转换  
    explicit operator double() const { return 3.14; } // 显式转换  
};

/*类成员在构造函数中初始化*/
class MyClass {  
public:  
    int mem1;  
    double mem2;  
  
    MyClass(int x, double y) : mem1(x), mem2(y) {}  
};

/*类成员直接在类内定义时初始化*/
class MyClass {  
public:  
    int mem1 = 0;  // 直接初始化  
    double mem2 {1.23}; // 使用大括号初始化  
  
    MyClass(int x, double y) : mem1(x), mem2(y) {} // 构造函数覆盖类内初始化  
};

int prices[] = {10, 20, 30};  
for (auto x : prices) {  
    // 对每个元素x执行操作  
}

std::array<int, 3> arr = {1, 2, 3};

// C++11之前可能需要这样写  
std::vector<std::vector<int> > matrix;  
// C++11及之后可以省略空格  
std::vector<std::vector<int>> matrix;

#include <iostream>  
  
int main() {  
    int x = 10, y = 13;  
    int&& r1 = x + y; // r1是一个右值引用，绑定到表达式x + y的结果（临时对象）  
    // 注意：直接对r1赋值是不合法的，因为r1是右值引用，但它绑定的值（23）是临时的  
  
    // 演示右值引用可以延长临时对象的生命周期  
    // 假设我们有一个函数，它接受一个右值引用参数  
    void process(int&& val) {  
        // 在这里，val是右值引用，它绑定到传入的临时对象或右值  
        // 我们可以访问val，就像它是一个普通的左值一样（尽管不能修改它，除非函数参数是非const的）  
        std::cout << "Processing value: " << val << std::endl;  
    }  
  
    // 调用process，传入一个右值（字面常量）  
    process(20);  
  
    // 注意：下面的代码是概念性的，实际中不能直接对r1赋值，因为r1绑定的是临时对象  
    // 但它说明了右值引用如何捕获临时对象的“生命”  
  
    return 0;  
}  
  
// 注意：上面的process函数示例中，我们实际上并没有展示如何通过右值引用来“移动”资源，  
// 因为移动语义通常涉及更复杂的场景，如类的移动构造函数和移动赋值运算符。

Resource createResource(size_t size) {  
    return Resource(size);  //调用Resource的构造函数
}  
  
int main() {  
    Resource r1 = createResource(1024); // 这里会发生深复制  
    // 假设后续代码...  
    return 0;  
}

class Useless {  
public:  
    int* pc;  
    size_t size;  
  
    // 常规复制构造函数  
    Useless(const Useless& f) : pc(new int[f.size]), size(f.size) {  
        // 深复制...  
    }  
  
    // 移动构造函数  
    Useless(Useless&& f) noexcept : pc(f.pc), size(f.size) {  
        //....省略浅复制过程
        f.pc = nullptr; // 窃取资源后，将原对象指针置为空  
        f.size = 0; // 可选，用于调试  
    }  
  
    // 移动赋值运算符  
    Useless& operator=(Useless&& f) noexcept {  
        if (this != &f) {   //f是一个右值引用
            delete[] pc; // 删除旧资源  
            pc = f.pc;  
            size = f.size;  
            f.pc = nullptr;  
            f.size = 0;  
        }  
        return *this;  
    }  
  
    // 其他成员函数...  
};  
  
// 使用示例  
Useless x;  
Useless y = std::move(x); //初始化,使用移动构造函数  
x = std::move(y); // 赋值,使用移动赋值运算符

Useless one, two;  
two = std::move(one); // 强制使用移动赋值运算符

class MyClass {  
public:  
    MyClass() = default; // 使用默认的默认构造函数  
    MyClass(MyClass&&) = default; // 使用默认的移动构造函数  
    // ...  
};

class MyClass {  
public:  
    MyClass(const MyClass&) = delete; // 禁用复制构造函数  
    MyClass& operator=(const MyClass&) = delete; // 禁用复制赋值运算符  
    // ...  
};

18.3.3 委托构造函数

        允许一个构造函数调用另一个构造函数来初始化对象，避免代码重复。

class MyClass {  
public:  
    MyClass() : MyClass(0) {} // 委托给接受一个int参数的构造函数  
    MyClass(int x) : value(x) {}  
private:  
    int value;  
};

/*
使用初始化列表（: MyClass(0)）来委托给接受一个int参数的构造函数。
这意味着，当创建MyClass类型的对象而不提供任何参数时，
它实际上会调用MyClass(int x)构造函数，并将0作为参数传递。
*/

18.3.4 继承构造函数

        允许派生类继承基类的构造函数，简化代码。

class Base {  
public:  
    Base(int, double) {}  
    // ...  
};  
  
class Derived : public Base {  
public:  
    using Base::Base; // 继承Base的所有构造函数（除了默认、复制和移动构造函数）  
    // ...  
};

18.3.5 管理虚方法：override和final

override：用于明确指出一个成员函数是重写基类中的虚函数。如果声明不匹配，编译器将报错。

class Base {  
public:  
    virtual void f(int) {}  
};  

class Derived : public Base {  
public:  
    void f(int) override {} // 正确重写  
    // void f(char) override {} // 错误：不匹配，将报错  
};

final：用于防止派生类进一步重写特定的虚函数。

class Base {  
public:  
    virtual void f() final {} // 禁止在派生类中重写  
};  

class Derived : public Base {  
public:  
    void f() override {} // 错误：Base::f() 是 final 的  
};

18.4 Lambda表达式

        在C++11及以后的版本中，lambda表达式（也称为lambda函数或lambda表达式）的引入极大地增强了C++的表达能力，特别是在与STL算法结合使用时。Lambda表达式提供了一种简洁的方式来定义匿名函数对象，这些对象可以捕获其所在作用域中的变量，并作为参数传递给接受函数指针或函数对象的STL算法。

Lambda表达式的基本语法

Lambda表达式的基本语法如下：

[capture](parameters) mutable -> return_type {  
    // 函数体  
}

capture：捕获列表，指定lambda表达式体中可以访问的外部变量。捕获方式可以是按值（=）或按引用（&）。

parameters：参数列表，与普通函数相同。

mutable：一个可选的说明符，表示lambda表达式体内的变量可以修改。

return_type：返回类型，可以省略，编译器会根据函数体自动推断。

函数体：包含lambda表达式要执行的代码。

Lambda表达式的使用场景

Lambda表达式在C++中非常有用，特别是在以下场景中：

简洁性：对于简单的函数对象，lambda表达式提供了一种更简洁的替代方案，避免了定义整个函数或函数符类的需要。

局部性：lambda表达式允许将函数定义放在其使用的地方附近，这有助于保持代码的清晰和可维护性。

捕获外部变量：lambda表达式可以捕获其所在作用域中的变量，这使得它们能够访问和操作这些变量，这在处理回调函数或事件处理器时特别有用。

#include <iostream>  
#include <vector>  
#include <numeric> // 包含std::accumulate  
  
int main() {  
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  
    int sum = std::accumulate(nums.begin(), nums.end(), 0,  
        [](int acc, int val) { return acc + (val % 2 == 0 ? val : 0); });  
    std::cout << "Sum of even numbers: " << sum << std::endl;  
    return 0;  
}

        [ ]：这是Lambda表达式的捕获列表，它是空的，意味着这个Lambda表达式不会捕获其所在作用域中的任何变量。在这个例子中，我们不需要捕获外部变量，因为Lambda表达式所需的所有信息（即累加器acc和当前值val）都是通过std::accumulate的参数传入的。

        (int acc, int val)：这是Lambda表达式的参数列表，它定义了Lambda表达式可以接受哪些参数。在这个例子中，它接受两个整型参数：acc（累加器，用于存储到目前为止的和）和val（当前正在处理的向量元素的值）。

        { return acc + (val % 2 == 0 ? val : 0); }：这是Lambda表达式的函数体，它指定了当Lambda表达式被调用时应该执行的操作。在这个例子中，函数体包含了一个返回语句，该语句使用三元运算符? :来检查val是否为偶数（即val % 2 == 0是否为真）。如果val是偶数，则返回val并将其加到累加器acc上；如果val是奇数，则返回0（即不对累加器acc做任何更改）。

        将这个Lambda表达式作为std::accumulate的第四个参数传递时，它会在每次迭代中调用，std::accumulate会提供当前的累加值（初始值为0）和向量中的当前元素值作为参数。因此，Lambda表达式实际上实现了一个自定义的累加逻辑，即只累加偶数元素的值。

18.5 包装器

        在C++中，std::function 是一个通用函数包装器，它可以包装几乎所有可调用的实体，包括普通函数、lambda 表达式、函数对象、以及可调用对象等。这使得 std::function 成为在泛型编程中处理可调用对象时非常有用的工具，特别是当你不确定或不想限制可调用对象的类型时。

std::function 的基本用法

        std::function 模板通常需要一个类型参数，这个参数指定了函数的签名（即返回类型和参数类型）。例如，std::function<double(double)> 可以包装任何接受一个 double 参数并返回一个 double 的可调用对象。

/*修改前的代码,多次实例化*/
#include <iostream>  
  
template<typename T, typename F>  
void use_f(T x, F f) {  
    static int count = 0;  
    std::cout << &count << " " << f(x) << std::endl;  
    ++count;  
}  
  
// ... 其他代码，包括可调用对象的定义和 use_f 的调用

/*修改后的代码*/
#include <iostream>  
#include <functional>  
  
template<typename T>  
void use_f(T x, std::function<double(T)> f) {  
    static int count = 0;  
    std::cout << &count << " " << f(x) << std::endl;  
    ++count;  
}  
  
int main() {  
    double dub(double x) { return x * 2.0; }  
    struct Fp { double operator()(double x) const { return x + 1.0; } };  
    auto fl = [](double x) { return x * x; };  
  
    use_f(3.0, dub);  
    use_f(3.0, Fp()(3.0));  // 注意这里不能直接传 Fp，因为 Fp 是类型不是对象  
    use_f(3.0, fl);  
    use_f(3.0, [](double x) { return x / 2.0; });  
    use_f(3.0, static_cast<double(*)(double)>(dub));  
    use_f(3.0, std::function<double(double)>(Fp()(3.0)));  // 错误用法，需要传递可调用对象  
  
    // 正确的使用 Fp 类型  
    Fp fp_obj;  
    use_f(3.0, fp_obj);  
  
    // 使用临时 std::function 对象  
    use_f(3.0, std::function<double(double)>([](double x) { return x * 3.0; }));  
}

18.6 可变参数模板

可变参数模板概述

        可变参数模板（Variadic Templates）是C++11引入的一个强大特性，允许模板函数和模板类接受任意数量和类型的参数。这主要通过模板参数包和函数参数包实现。

模板参数包和函数参数包

模板参数包：使用省略号（...）表示，可以包含任意数量和类型的模板参数。

函数参数包：使用省略号（...）表示，可以包含任意数量和类型的函数参数。

示例：显示参数列表

        假设要编写一个show_list函数，该函数接受任意数量和类型的参数（只要这些参数可以被std::cout显示），并将它们以逗号分隔的形式输出。

展开参数包

        参数包不能直接通过索引访问，但可以使用递归或C++17引入的折叠表达式来“展开”它们。

/*折叠表达式*/
#include <iostream>  
  
template<int... Ns>  
int sum() {  
    return (... + Ns); // 使用折叠表达式来计算所有Ns的和  
}  
  
int main() {  
    std::cout << "Sum: " << sum<1, 2, 3, 4>() << std::endl; // 输出: Sum: 10  
    return 0;  
}

递归实现

        递归是处理可变参数模板的一种常见方法。基本思路是：

        处理参数包中的第一个参数。

        递归调用自身，处理剩余的参数。

        提供一个终止递归的基准情况（通常是参数包为空）。

template<typename T, typename... Args>  
void show_list(const T& first, Args... args) {  
    std::cout << first;  
    if constexpr (sizeof...(args) > 0) {  
        std::cout << ", ";  
        show_list(args...);  
    } else {  
        std::cout << std::endl;  
    }  
}  
  
// 使用示例  
show_list(1, "Hello", 3.14, std::string("World"));
/*
if constexpr 会在编译时评估条件，并根据条件的结果来包含或排除代码块。
这意味着，如果条件在编译时确定为 false，
则 if constexpr 对应的代码块将不会被编译到最终的程序中，这有助于减少编译后的程序大小
*/

18.7 C++11新增的其他功能

C++11 总结与精要

1. 并行编程

        C++11支持多线程编程，通过thread_local关键字和线程库（thread, mutex, condition_variable, future）提供工具。

        多线程适合处理并行任务，但需注意线程安全和同步问题。

2. 新增库

        随机数库 (<random>)：提供更复杂的随机数生成器和分布。

        时间库 (<chrono>)：处理时间间隔。

        元组库 (<tuple>)：支持存储多个不同类型值的元组。

        有理数库 (<ratio>)：支持编译时的有理数算术。

        正则表达式库 (<regex>)：强大的文本匹配工具。

3. 低级编程

        POD扩展：放宽了POD（Plain Old Data）的要求，使其更灵活。通俗的讲,一个类或结构体通过二进制拷贝后还能保持其数据不变,那么它就是一个POD类型。 

        共用体改进：允许成员拥有构造函数和析构函数。

        内存对齐：alignof运算符和alignas说明符支持更精确的内存控制。

        constexpr：允许在编译时计算常量表达式，有助于嵌入式编程。

4. 杂项

        扩展整型 (<cstdint>)：支持C99中的扩展整型。

        用户定义字面量：通过字面量运算符定义新的字面量表示法。

        编译时断言 (static_assert)：在编译阶段进行断言测试。

        元编程支持：加强模板元编程能力。

5. 语言变化

        标准委员会：ISO/IEC JTC1/SC22/WG21负责C++标准的发展。

        库影响标准：STL和Boost库等社区努力推动了C++标准的发展。

        Boost库：提供了大量实用库，许多已融入C++11。

6. 高效使用C++

        面向对象编程：学习类设计、用例分析和CRC卡片等高级技术。

        系统方法：如UML用于项目建模。

        特定平台库：如Windows API、Apple Xcode等，简化平台编程。

7. 代码示例

        Boost库使用示例：lexical_cast 用于类型转换。

#include <boost/lexical_cast.hpp>  
#include <iostream>  
#include <string>  
  
int main() {  
    int i = boost::lexical_cast<int>("123");  
    std::string s = boost::lexical_cast<std::string>(123.456);  
  
    std::cout << "Int: " << i << ", String: " << s << std::endl;  
  
    // 注意：浮点数转换到字符串可能无法精确控制格式  
    double d = 123.456789;  
    std::string ds = boost::lexical_cast<std::string>(d);  
    std::cout << "Double to string: " << ds << std::endl;  
  
    return 0;  
}