#pragma once
#include "中文化.hpp"
#include "异常.hpp"
#include "顺序表.hpp"
命名空间 中文标准 {
模板 <类型名 类型1, 长度单位 节点大小 = 64>
类 链串 {
公开的:
    /* 初始化为空链串 */
    链串() {
        对象->长度 = 0;
        对象->下一个 = 空指针;
        对象->上一个 = 空指针;
        对象->头 = 对象; /* 每一个子节点都记录同一个头结点 */
        对象->尾 = 对象; /* 为了方便，只有头结点记录尾节点 */
    }

    链串 (常量 std::initializer_list<类型1>& init = {})
    {
        计次循环(适应 & 东西: init) {
            插入(东西);
        }
    }

    /*
     * 链式析构
     *
     * 析构时，会递归析构所有节点。
     */
    ~链串() {
        删除[] 对象->下一个;
    }

    空类型 插入(常量 类型1& 元素) {
        链串 *暂时 = 对象->尾;
        如果(暂时->长度 等于 节点大小)
            _推();
        暂时->存储[暂时->长度++] = 元素;
    }

    长度单位 统计() {
        长度单位 总数 = 0;
        链串 *暂时 = 对象->头;
        判断循环(暂时 != 空指针) {
            总数 += 暂时->长度;
            暂时 = 暂时->下一个;
        }
        返回 总数;
    }

    /*
     * 链串重组
     *
     * 将链串重组为顺序表W
     */
    顺序表<类型1> 重组() {
        顺序表<类型1> 结果(统计());
        链串 *暂时 = 对象->头;
        长度单位 计数 = 0;
        判断循环(暂时 != 空指针) {
            计次循环(适应 索引 = 0; 索引 < 暂时->长度; ++索引) {
                结果[计数++] = 暂时->存储[索引];
            }
            暂时 = 暂时->下一个;
        }
        返回 结果;
    }
    
    类 链串异常: 公开的 标准异常{
    公开的:
        链串异常(常量 字符* 消息) : 标准异常(消息) {}
    };
私有的:
    类型1 存储[节点大小];
    长度单位 长度; /* 存储中的元素数量 */
    链串 *下一个;
    链串 *上一个;
    链串 *头;
    链串 *尾;

    空类型 _推() {
        链串*新的;
        尝试{ 新的  = 新建 链串(); }
        捕获异常 (std::exception& exp){
            抛出异常 链串异常{"链串推失败"};
        }
        _拼接节点(新的);
    }

    空类型 _拼接节点(链串* 新的) {
        对象->尾->下一个 = 新的;
        新的->上一个 = 对象->尾;
        对象->尾 = 新的;
        新的->头 = 对象;
    }
};
}