C++容器类高级特性：C++11_14_17新特性的实战应用

# 1. C++容器类概述

## 1.1 C++容器类定义
容器类是C++标准库中的一个核心组件，用于存储和管理一组对象。它们允许开发者通过提供一致的接口来操作不同类型的数据集合，而无需关心数据底层存储的细节。容器类通常包括序列容器和关联容器两大类，例如vector、list、map和set等。

## 1.2 C++容器类的特点
容器类的特点包括高效的数据访问、数据结构的灵活性以及良好的可扩展性。它们能够根据数据量动态调整大小，并提供了丰富的成员函数，如插入、删除、遍历和排序等。此外，C++标准容器通过模板实现，使其能够处理任意类型的数据。

## 1.3 C++容器类的使用场景
C++容器类广泛应用于各种场景，如数据结构的实现、算法的辅助以及大型项目的模块化设计中。合理使用容器类可以提高代码的复用性，降低数据管理的复杂度，优化程序性能。在接下来的章节中，我们将深入探讨C++容器类的更多高级特性和应用技巧。

# 2. C++11新特性在容器类中的应用

C++11标准的引入，为C++语言带来了诸多创新，特别是在容器类的应用上。这些新特性的加入，不仅提升了容器类的表达能力，也极大地丰富了其功能。本章节我们将深入探讨C++11中引入到容器类中的新特性，包括新增的容器类、智能指针与容器类的结合使用，以及容器类并发访问的控制策略。

## 2.1 新增的容器类

C++11标准中新增了两种容器类：`unordered_map`和`unordered_set`。它们提供了基于哈希表的快速访问机制，这在处理大量数据时特别有用。

### 2.1.1 unordered_map和unordered_set的使用和性能分析

`unordered_map`和`unordered_set`是基于哈希表实现的容器，它们提供平均常数时间复杂度的插入、查找和删除操作。与基于平衡二叉树的`map`和`set`相比，`unordered_map`和`unordered_set`在处理随机数据分布时具有更高的效率。

#### 使用示例

下面是一个简单的使用`unordered_map`的示例，展示了如何插入、查询和删除元素：

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<std::string, int> ages;

    // 插入元素
    ages["John"] = 35;
    ages["Jane"] = 32;
    ages["Doe"] = 29;

    // 查询元素
    auto it = ages.find("Jane");
    if (it != ages.end()) {
        std::cout << "Jane is " << it->second << " years old." << std::endl;
    }

    // 删除元素
    ages.erase("Doe");

    return 0;
}

#### 性能分析

`unordered_map`和`unordered_set`的性能依赖于哈希函数的质量和负载因子。在理想情况下，负载因子应保持在较低水平以确保快速的访问速度。哈希冲突的解决通常采用开放寻址法或链表法。

### 2.1.2 array和tuple的应用实例

C++11还引入了`array`和`tuple`两种容器类。`array`是固定大小的数组容器，而`tuple`是不可变的固定大小容器，可以存储不同类型的数据。

#### array的应用

#include <array>
#include <iostream>

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

    // 修改元素
    arr[1] = 4;

    // 遍历
    for (const auto& value : arr) {
        std::cout << value << ' ';
    }
    std::cout << std::endl;

    return 0;
}

#### tuple的应用

`tuple`可以用来组合不同类型的数据。

#include <tuple>
#include <iostream>

int main() {
    std::tuple<int, std::string, char> person = std::make_tuple(30, "John", 'M');

    // 访问tuple元素
    std::cout << "Age: " << std::get<0>(person) << std::endl;
    std::cout << "Name: " << std::get<1>(person) << std::endl;
    std::cout << "Gender: " << std::get<2>(person) << std::endl;

    return 0;
}

### 2.2 智能指针和容器类的结合使用

智能指针如`std::shared_ptr`和`std::weak_ptr`能够帮助自动管理内存，避免内存泄漏和野指针问题，将它们和容器类结合使用，可以进一步提高程序的安全性和健壮性。

#### 2.2.1 shared_ptr和weak_ptr的基本用法

`shared_ptr`允许多个指针共享同一个对象的所有权，当最后一个`shared_ptr`被销毁时，对象也会被自动删除。

#include <memory>
#include <iostream>

int main() {
    auto sp1 = std::make_shared<int>(42);
    std::shared_ptr<int> sp2 = sp1;

    // 输出引用计数
    std::cout << "Reference count: " << sp1.use_count() << std::endl;

    return 0;
}

`weak_ptr`是一种弱引用智能指针，不增加引用计数，用于解决`shared_ptr`可能产生的循环引用问题。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp;

    // 尝试创建一个指向相同对象的shared_ptr
    std::shared_ptr<int> sp2 = wp.lock();
    if (sp2) {
        std::cout << "Weak pointer can be promoted to shared pointer." << std::endl;
    }

    return 0;
}

#### 2.2.2 容器类中智能指针的管理策略

在容器类中管理智能指针时，应使用`std::vector<std::shared_ptr<T>>`来存储对象，以保证容器销毁时，所有对象也能够被适当地释放。

#include <vector>
#include <memory>
#include <iostream>

class MyClass {};

int main() {
    std::vector<std::shared_ptr<MyClass>> myVec;

    // 添加元素到vector
    for (int i = 0; i < 5; ++i) {
        myVec.push_back(std::make_shared<MyClass>());
    }

    // vector销毁时，所有MyClass对象也会被销毁
    return 0;
}

### 2.3 容器类的并发访问控制

随着多核处理器的普及，多线程程序变得越来越普遍。C++11引入了并发编程的特性，其中`mutex`和`lock`可以用来控制容器类的并发访问，确保线程安全。

#### 2.3.1 mutex和lock在容器类中的使用

`std::mutex`和相关的互斥锁(`std::unique_lock`、`std::shared_lock`等)可以用来保护共享资源，以防止数据竞争。

#include <vector>
#include <mutex>
#include <thread>
#include <iostream>

std::vector<int> myVec;
std::mutex myMutex;

void addValue(int value) {
    std::lock_guard<std::mutex> lock(myMutex);
    myVec.push_back(value);
}

int main() {
    std::vector<std::thread> threads;

    // 创建10个线程，每个线程向vector中添加一个值
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(addValue, i));
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

#### 2.3.2 线程安全的容器类实现方式

使用标准库提供的`std::lock_guard`或`std::unique_lock`等RAII(资源获取即初始化)机制，可以方便地管理锁的生命周期，并保证即使发生异常也能释放资源。

#include <mutex>
#include <vector>
#include <iostream>

class ThreadSafeVector {
public:
    void push_back(int value) {
        std::lock_guard<std::mutex> lock(mutex_);
        myVec.push_back(value);
    }

    int size() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return myVec.size();
    }

private:
    std::vector<int> myVec;
    mutable std::mutex mutex_;
};

int main() {
    ThreadSafeVector tsVec;
    tsVec.push_back(1);
    tsVec.push_back(2);
    std::cout << "Vector size: " << tsVec.size() << std::endl;
    return 0;
}

## 第二章小结

C++11新特性为容器类的应用带来了革命性的变化。新增的容器类如`unordered_map`和`unordered_set`通过哈希表机制提供了高效的数据管理。`array`和`tuple`则分别提供了固定大小的数组和可容纳异构数据的类型。智能指针的引入，如`shared_ptr`和`weak_ptr`，极大地增强了内存管理的灵活性与安全性。在并发编程方面，`mutex`和`lock`的加入使得在多线程环境下安全地使用容器类成为可能。这些新特性不仅提升了容器类的性能，还优化了内存管理，增强了程序的并发能力。在下一章节中，我们将探讨C++14对容器类的改进。

# 3. C++14对容器类的改进

C++14标准引入了若干特性，