别名模板与模板模板参数

template <typename T>
using StringMap = std::map<std::string, T>;
// StringMap<int> 等价于 std::map<std::string, int>

template <template <typename> class Container>
class Wrapper { Container<int> data_; };

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>

// ====== 别名模板：简化常用容器声明 ======

template <typename T>
using Vector = std::vector<T>;

// 学生名 → 某类型值的映射
template <typename ValueType>
using ScoreSheet = std::map<std::string, ValueType>;

// 学生名 → 成绩列表
template <typename ScoreType>
using StudentScores = ScoreSheet<Vector<ScoreType>>;

// ====== 模板模板参数：可替换底层容器的包装类 ======

template <typename T, template <typename...> class Container = Vector>
class ScoreManager {
public:
    void addScore(const std::string& student, T score) {
        data_[student].push_back(score);
    }

    double average(const std::string& student) const {
        auto it = data_.find(student);
        if (it == data_.end() || it->second.empty()) return 0.0;

        T sum = T{};
        for (const auto& s : it->second) sum += s;
        return static_cast<double>(sum) / it->second.size();
    }

    T highest(const std::string& student) const {
        auto it = data_.find(student);
        if (it == data_.end() || it->second.empty()) return T{};
        return *std::max_element(it->second.begin(), it->second.end());
    }

    void printReport() const {
        std::cout << "========== 成绩报告 ==========" << std::endl;
        for (const auto& [student, scores] : data_) {
            std::cout << student << ": ";
            std::cout << "[";
            for (size_t i = 0; i < scores.size(); ++i) {
                if (i > 0) std::cout << ", ";
                std::cout << scores[i];
            }
            std::cout << "]";
            std::cout << "  平均: " << average(student)
                      << "  最高: " << highest(student) << std::endl;
        }
    }

private:
    StudentScores<T> data_;  // 使用别名模板
};

// ====== 别名模板做类型萃取 ======

template <typename T>
using RemoveRef = typename std::remove_reference<T>::type;

template <typename T>
using AddConst = const T;

template <typename T>
using Ptr = T*;

int main() {
    std::cout << "===== 别名模板 —— 简化声明 =====" << std::endl;

    // 等价于 std::map<std::string, std::vector<int>>
    StudentScores<int> scores;

    scores["张三"] = Vector<int>{85, 92, 78};
    scores["李四"] = Vector<int>{90, 95, 88, 76};
    scores["王五"] = Vector<int>{70, 80, 75};

    for (const auto& [name, vec] : scores) {
        std::cout << name << " 有 " << vec.size() << " 门成绩" << std::endl;
    }

    std::cout << "\n===== 模板模板参数 —— 可替换容器 =====" << std::endl;

    ScoreManager<int> mgr;
    mgr.addScore("张三", 85);
    mgr.addScore("张三", 92);
    mgr.addScore("张三", 78);
    mgr.addScore("李四", 90);
    mgr.addScore("李四", 95);
    mgr.addScore("李四", 88);
    mgr.printReport();

    // 类型萃取别名
    std::cout << "\n===== 类型萃取别名 =====" << std::endl;
    using RefInt = int&;
    using BareInt = RemoveRef<RefInt>;  // = int
    std::cout << "RemoveRef<int&> is int? "
              << std::is_same<BareInt, int>::value << std::endl;

    Ptr<const int> p = nullptr;  // AddConst<int>* → const int*
    std::cout << "Ptr<AddConst<int>> is const int*? "
              << std::is_same<Ptr<AddConst<int>>, const int*>::value << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <memory>

// 模板模板参数：通过编译期策略切换底层容器
template <typename T, template <typename...> class Container = std::vector>
class ObjectPool {
public:
    template <typename... Args>
    T* acquire(Args&&... args) {
        auto obj = std::make_unique<T>(std::forward<Args>(args)...);
        T* ptr = obj.get();
        pool_.push_back(std::move(obj));
        return ptr;
    }

    size_t size() const { return pool_.size(); }

    void print() const {
        std::cout << "Pool 中的对象 (" << pool_.size() << "):" << std::endl;
        for (const auto& obj : pool_) {
            std::cout << "  @ " << obj.get() << std::endl;
        }
    }

private:
    // pool_ 是 Container<unique_ptr<T>>
    Container<std::unique_ptr<T>> pool_;
};

struct Widget {
    int id;
    explicit Widget(int id) : id(id) {}
};

int main() {
    std::cout << "===== 使用 vector 作为底层容器 =====" << std::endl;
    ObjectPool<Widget> vector_pool;  // 默认 Container = std::vector
    vector_pool.acquire(1);
    vector_pool.acquire(2);
    vector_pool.acquire(3);
    vector_pool.print();

    std::cout << "\n===== 使用 list 作为底层容器 =====" << std::endl;
    ObjectPool<Widget, std::list> list_pool;
    list_pool.acquire(10);
    list_pool.acquire(20);
    list_pool.print();

    std::cout << "\n===== 使用 deque 作为底层容器 =====" << std::endl;
    ObjectPool<Widget, std::deque> deque_pool;
    deque_pool.acquire(100);
    deque_pool.print();

    return 0;
}