脚本网页 C与汇编详解

以下是详细内容
html 复制代码
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>C/C++不是对汇编的简单封装</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Microsoft YaHei', sans-serif;
            font-size: 12px;
            line-height: 1.4;
            color: #333;
            background: #f5f5f5;
            overflow-x: hidden;
        }
        
        .container {
            max-width: 100%;
            min-height: 100vh;
            position: relative;
        }
        
        .page {
            width: 100%;
            min-height: 100vh;
            padding: 12px;
            display: none;
            animation: fadeIn 0.3s ease-in-out;
            background: white;
            overflow-y: auto;
        }
        
        .page.active {
            display: block;
        }
        
        @keyframes fadeIn {
            from { opacity: 0; transform: translateX(20px); }
            to { opacity: 1; transform: translateX(0); }
        }
        
        h1 {
            font-size: 16px;
            font-weight: bold;
            margin-bottom: 12px;
            color: #1a1a1a;
            border-bottom: 2px solid #4CAF50;
            padding-bottom: 6px;
        }
        
        h2 {
            font-size: 14px;
            font-weight: bold;
            margin: 10px 0 6px;
            color: #2c3e50;
        }
        
        h3 {
            font-size: 13px;
            font-weight: 600;
            margin: 8px 0 5px;
            color: #34495e;
        }
        
        p {
            margin-bottom: 6px;
            text-align: justify;
        }
        
        ul, ol {
            margin: 6px 0;
            padding-left: 18px;
        }
        
        li {
            margin-bottom: 4px;
        }
        
        .highlight {
            background: #fff3cd;
            padding: 1px 3px;
            border-radius: 2px;
        }
        
        .code-block {
            background: #f8f9fa;
            border: 1px solid #e9ecef;
            border-radius: 3px;
            padding: 6px;
            margin: 6px 0;
            font-family: 'Consolas', 'Monaco', monospace;
            font-size: 11px;
            overflow-x: auto;
        }
        
        .flow-diagram {
            background: #e8f5e9;
            border: 1px solid #c8e6c9;
            border-radius: 3px;
            padding: 8px;
            margin: 8px 0;
            font-size: 11px;
        }
        
        .navigation {
            position: fixed;
            bottom: 8px;
            left: 50%;
            transform: translateX(-50%);
            display: flex;
            gap: 6px;
            background: rgba(255, 255, 255, 0.95);
            padding: 6px;
            border-radius: 20px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
            z-index: 1000;
        }
        
        .nav-btn {
            padding: 5px 10px;
            background: #4CAF50;
            color: white;
            border: none;
            border-radius: 15px;
            cursor: pointer;
            font-size: 11px;
            transition: all 0.3s;
        }
        
        .nav-btn:hover {
            background: #45a049;
            transform: scale(1.05);
        }
        
        .nav-btn:disabled {
            background: #ccc;
            cursor: not-allowed;
            transform: scale(1);
        }
        
        .page-indicator {
            display: flex;
            align-items: center;
            gap: 4px;
            font-size: 10px;
            color: #666;
        }
        
        .dot {
            width: 6px;
            height: 6px;
            border-radius: 50%;
            background: #ddd;
            transition: all 0.3s;
        }
        
        .dot.active {
            background: #4CAF50;
            transform: scale(1.3);
        }
        
        .key-point {
            border-left: 3px solid #4CAF50;
            padding-left: 8px;
            margin: 8px 0;
        }
        
        .comparison-table {
            width: 100%;
            border-collapse: collapse;
            margin: 8px 0;
            font-size: 11px;
        }
        
        .comparison-table th,
        .comparison-table td {
            border: 1px solid #ddd;
            padding: 4px;
            text-align: left;
        }
        
        .comparison-table th {
            background: #f2f2f2;
            font-weight: bold;
        }
    </style>
</head>
<body>
    <div class="container">
        <!-- 第1页：总体概述 -->
        <div class="page active" id="page1">
            <h1>总体概述：为什么说C/C++不是对汇编的简单封装？</h1>
            
            <h2>核心论点</h2>
            <p>将C/C++简单描述为"对汇编的封装"是一个严重的过度简化。这种说法忽略了编译器、链接器、ABI（应用程序二进制接口）、操作系统和硬件体系结构之间层层叠叠的抽象层次。</p>
            
            <h2>本文结构</h2>
            <ol>
                <li><strong>C语言的定位</strong> - 作为"可移植汇编"的真实含义</li>
                <li><strong>C++的复杂性</strong> - 面向对象、泛型等高级抽象</li>
                <li><strong>编译链路详解</strong> - 从源码到可执行文件的完整流程</li>
                <li><strong>反例对比</strong> - 其他语言与机器码的关系</li>
                <li><strong>最终结论</strong> - 准确的理解和定位</li>
            </ol>
            
            <h2>关键概念预览</h2>
            <div class="key-point">
                <p><span class="highlight">抽象层次</span>：C/C++在机器码之上建立了多层抽象，每层都有其独立语义</p>
            </div>
            <div class="key-point">
                <p><span class="highlight">编译器魔法</span>：现代编译器不仅仅是翻译，更是优化和重构</p>
            </div>
            <div class="key-point">
                <p><span class="highlight">语言语义</span>：高级语言的语义与机器指令没有直接对应关系</p>
            </div>
            
            <h2>常见误解澄清</h2>
            <ul>
                <li>误解1：C代码能直接对应汇编指令</li>
                <li>误解2：编译器只是简单的代码转换器</li>
                <li>误解3：所有语言最终都是汇编，所以都是汇编封装</li>
            </ul>
        </div>
        
        <!-- 第2页：C语言详细说明 -->
        <div class="page" id="page2">
            <h1>C语言：可移植的汇编</h1>
            
            <h2>历史背景</h2>
            <p>C语言诞生于1972年，由丹尼斯·里奇在贝尔实验室开发，最初目的是为了编写Unix操作系统。在此之前，Unix主要用汇编语言编写，可移植性极差。</p>
            
            <h2>设计哲学</h2>
            <p>C语言的设计哲学是"相信程序员"，提供了接近硬件的控制能力，同时保持了高级语言的结构化特性。</p>
            
            <h2>核心特性分析</h2>
            <h3>1. 内存控制能力</h3>
            <div class="code-block">
// 直接内存操作
int *ptr = (int*)0x1000;  // 直接访问特定内存地址
*ptr = 0xDEADBEEF;        // 写入特定值

// 位操作
unsigned char flag = 0x00;
flag |= 0x01;  // 设置第0位
flag &= ~0x02; // 清除第1位
            </div>
            
            <h3>2. 数据布局控制</h3>
            <div class="code-block">
struct PackedData {
    char a;
    int b;
    short c;
} __attribute__((packed));  // 紧凑布局，无填充

// 获取结构体成员偏移
size_t offset = offsetof(struct PackedData, b);
            </div>
            
            <h3>3. 内联汇编支持</h3>
            <div class="code-block">
// GCC内联汇编示例
uint64_t rdtsc(void) {
    uint32_t low, high;
    __asm__ __volatile__("rdtsc" : "=a"(low), "=d"(high));
    return ((uint64_t)high << 32) | low;
}
            </div>
            
            <h2>为什么不是"宏包裹的汇编"？</h2>
            <ul>
                <li><strong>类型系统</strong>：C有完整的类型检查，汇编没有</li>
                <li><strong>作用域规则</strong>：C有词法作用域，汇编是平坦的</li>
                <li><strong>控制结构</strong>：if/else、while、for等高级控制流</li>
                <li><strong>函数调用约定</strong>：标准化的参数传递和返回值机制</li>
            </ul>
            
            <h2>可移植性的实现</h2>
            <p>通过编译器前端统一处理C代码，后端针对不同架构生成对应汇编，实现了"一次编写，多处编译"。</p>
            
            <div class="comparison-table">
                <table>
                    <tr>
                        <th>特性</th>
                        <th>汇编</th>
                        <th>C语言</th>
                    </tr>
                    <tr>
                        <td>可移植性</td>
                        <td>无（架构相关）</td>
                        <td>高（编译器处理）</td>
                    </tr>
                    <tr>
                        <td>类型安全</td>
                        <td>无</td>
                        <td>有（静态类型）</td>
                    </tr>
                    <tr>
                        <td>抽象层次</td>
                        <td>机器指令</td>
                        <td>高级语言构造</td>
                    </tr>
                </table>
            </div>
        </div>
        
        <!-- 第3页：C++详细说明 -->
        <div class="page" id="page3">
            <h1>C++：多重抽象的复杂系统</h1>
            
            <h2>从C到C++的飞跃</h2>
            <p>C++在C的基础上引入了面向对象编程、泛型编程、异常处理、RTTI（运行时类型信息）等高级特性，这些特性在汇编层面完全没有对应概念。</p>
            
            <h2>面向对象机制</h2>
            <h3>1. 虚函数表（vtable）</h3>
            <div class="code-block">
class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override { /* 绘制圆形 */ }
};

// 编译器生成的内部结构（概念性）
struct Shape_vtable {
    void (*draw)(Shape*);
    void (*destructor)(Shape*);
};

struct Shape {
    Shape_vtable* vptr;
};
            </div>
            
            <h3>2. 多重继承的内存布局</h3>
            <div class="code-block">
class A { int a; };
class B { int b; };
class C : public A, public B { int c; };

// 内存布局可能包含多个vptr指针
// 需要指针调整（this pointer adjustment）
            </div>
            
            <h2>模板元编程</h2>
            <div class="code-block">
// 编译期计算斐波那契数列
template<int N>
struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

template<>
struct Fibonacci<0> { static const int value = 0; };

template<>
struct Fibonacci<1> { static const int value = 1; };

// 在编译期就计算完成，运行时只是常量
int main() {
    int x = Fibonacci<10>::value;  // 编译期已计算为55
}
            </div>
            
            <h2>异常处理机制</h2>
            <p>C++异常处理需要在编译时生成额外的元数据：</p>
            <ul>
                <li>展开表（unwind tables）</li>
                <li>Landing pads</li>
                <li>类型信息（typeinfo）</li>
            </ul>
            
            <div class="code-block">
try {
    risky_operation();
} catch (const std::exception& e) {
    // 需要类型匹配和栈展开
    handle_error(e);
}

// 生成的汇编包含：
// 1. try块边界标记
// 2. 异常类型信息
// 3. 清理代码（析构函数调用）
// 4. 栈展开逻辑
            </div>
            
            <h2>STL的复杂性</h2>
            <div class="code-block">
std::vector<int> v = {1, 2, 3};

// 背后的复杂机制：
// 1. 模板实例化
// 2. 内存分配器（allocator）
// 3. 迭代器实现
// 4. 异常安全保证
// 5. RAII资源管理
// 6. 移动语义优化
            </div>
            
            <h2>名字修饰（Name Mangling）</h2>
            <div class="code-block">
// C++源码
namespace NS {
    class MyClass {
        void foo(int);
    };
}

// 编译后的符号名（GCC）
// _ZN2NS7MyClass3fooEi
            </div>
            
            <h2>编译器优化示例</h2>
            <div class="code-block">
// 原始C++代码
int sum = 0;
for (int i = 0; i < 100; ++i) {
    sum += i * 2;
}

// 优化后的汇编可能变成：
// mov eax, 9900  // 直接计算结果
// 因为编译器在编译期就计算了 2 * (0+1+...+99)
            </div>
        </div>
        
        <!-- 第4页：编译链路详解 -->
        <div class="page" id="page4">
            <h1>编译链路：从源码到可执行文件</h1>
            
            <h2>完整编译流程</h2>
            <div class="flow-diagram">
                源文件(.cpp) → 预处理器 → 编译器前端 → 中间表示(IR) → 优化器 → 编译器后端 → 汇编代码(.s) → 汇编器 → 目标文件(.o) → 链接器 → 可执行文件
            </div>
            
            <h2>1. 预处理阶段</h2>
            <ul>
                <li>处理#include指令</li>
                <li>宏展开</li>
                <li>条件编译（#ifdef/#ifndef）</li>
                <li>删除注释</li>
            </ul>
            
            <h2>2. 编译器前端</h2>
            <h3>词法分析</h3>
            <p>将源代码转换为token流：</p>
            <div class="code-block">
int x = 42;
// Tokens: INT, IDENTIFIER, EQUAL, NUMBER, SEMICOLON
            </div>
            
            <h3>语法分析</h3>
            <p>构建抽象语法树（AST）：</p>
            <div class="code-block">
// if (x > 0) return x;
// AST结构:
// IfStatement
//  ├── Condition: BinaryOp(>, x, 0)
//  └── Then: ReturnStatement(x)
            </div>
            
            <h3>语义分析</h3>
            <ul>
                <li>类型检查</li>
                <li>作用域解析</li>
                <li>重载决议</li>
                <li>模板实例化</li>
            </ul>
            
            <h2>3. 中间表示（IR）</h2>
            <p>现代编译器使用IR作为优化桥梁：</p>
            <div class="code-block">
// LLVM IR示例
define i32 @add(i32 %a, i32 %b) {
entry:
  %sum = add i32 %a, %b
  ret i32 %sum
}
            </div>
            
            <h2>4. 优化器</h2>
            <h3>常见优化技术</h3>
            <ul>
                <li><strong>常量折叠</strong>：编译期计算常量表达式</li>
                <li><strong>死代码消除</strong>：删除不可达代码</li>
                <li><strong>循环展开</strong>：减少循环开销</li>
                <li><strong>内联函数</strong>：消除函数调用开销</li>
                <li><strong>向量化</strong>：使用SIMD指令</li>
            </ul>
            
            <div class="code-block">
// 优化前
for (int i = 0; i < 4; ++i) {
    a[i] = b[i] + c[i];
}

// 向量化优化后（伪汇编）
// movdqa xmm0, [b]
// paddd xmm0, [c]
// movdqa [a], xmm0
            </div>
            
            <h2>5. 编译器后端</h2>
            <h3>指令选择</h3>
            <p>将IR映射到目标机器指令：</p>
            <div class="code-block">
// IR: %result = add i32 %a, %b
// x86: add eax, ebx
// ARM: add r0, r0, r1
            </div>
            
            <h3>寄存器分配</h3>
            <p>将虚拟寄存器映射到物理寄存器，需要处理寄存器溢出。</p>
            
            <h3>指令调度</h3>
            <p>重排指令以避免流水线停顿，提高指令级并行。</p>
            
            <h2>6. 汇编器和链接器</h2>
            <h3>汇编器工作</h3>
            <ul>
                <li>将汇编代码转换为机器码</li>
                <li>生成符号表</li>
                <li>生成重定位信息</li>
            </ul>
            
            <h3>链接器工作</h3>
            <ul>
                <li>符号解析</li>
                <li>地址重定位</li>
                <li>库链接</li>
                <li>生成最终可执行文件</li>
            </ul>
            
            <h2>优化对代码的改变</h2>
            <p>经过优化后，生成的汇编可能与原始代码逻辑完全不同：</p>
            <div class="code-block">
// 原始代码
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// 尾递归优化后可能变成循环
// 或者对于常量参数直接计算结果
            </div>
        </div>
        
        <!-- 第5页：反例对比 -->
        <div class="page" id="page5">
            <h1>反例对比：其他语言与机器码</h1>
            
            <h2>Python的例子</h2>
            <p>Python的CPython实现最终也生成机器码，但没人说"Python是对汇编的封装"：</p>
            
            <h3>Python的执行模型</h3>
            <div class="code-block">
# Python源码
def add(a, b):
    return a + b

# 字节码（通过dis模块查看）
# 0 LOAD_FAST 0 (a)
# 2 LOAD_FAST 1 (b)
# 4 BINARY_ADD
# 6 RETURN_VALUE
            </div>
            
            <p>Python通过解释器执行字节码，解释器本身是编译的C代码。这里有多层抽象：Python代码 → 字节码 → 解释器 → 机器码。</p>
            
            <h2>Java的例子</h2>
            <h3>JVM执行模型</h3>
            <div class="flow-diagram">
                Java源码 → Java编译器 → 字节码(.class) → JVM解释器/JIT编译器 → 机器码
            </div>
            
            <ul>
                <li><strong>解释执行</strong>：JVM逐条解释字节码</li>
                <li><strong>JIT编译</strong>：热点代码动态编译为机器码</li>
                <li><strong>GC管理</strong>：自动内存管理，程序员无需关心</li>
            </ul>
            
            <h2>JavaScript的例子</h2>
            <p>V8引擎的执行流程：</p>
            <ol>
                <li>解析器生成AST</li>
                <li>Ignition解释器执行字节码</li>
                <li>TurboFan编译热点代码为优化机器码</li>
                <li>去优化：当假设失效时回退到解释执行</li>
            </ol>
            
            <h2>对比分析</h2>
            <div class="comparison-table">
                <table>
                    <tr>
                        <th>语言</th>
                        <th>执行方式</th>
                        <th>抽象层次</th>
                        <th>是否"汇编封装"</th>
                    </tr>
                    <tr>
                        <td>C</td>
                        <td>静态编译</td>
                        <td>低（接近硬件）</td>
                        <td>部分正确但不准确</td>
                    </tr>
                    <tr>
                        <td>C++</td>
                        <td>静态编译</td>
                        <td>中（多层抽象）</td>
                        <td>不准确</td>
                    </tr>
                    <tr>
                        <td>Java</td>
                        <td>JVM</td>
                        <td>高（虚拟机抽象）</td>
                        <td>明显不是</td>
                    </tr>
                    <tr>
                        <td>Python</td>
                        <td>解释器</td>
                        <td>极高（动态语言）</td>
                        <td>明显不是</td>
                    </tr>
                </table>
            </div>
            
            <h2>关键区别</h2>
            <h3>1. 语义距离</h3>
            <ul>
                <li><strong>语义接近度</strong>：语言构造与机器概念的对应程度</li>
                <li><strong>抽象层级</strong>：需要跨越多少抽象层才能到达机器码</li>
            </ul>
            
            <h3>2. 运行时支持</h3>
            <ul>
                <li><strong>GC</strong>：自动垃圾回收</li>
                <li><strong>反射</strong>：运行时类型检查</li>
                <li><strong>动态加载</strong>：运行时代码生成</li>
            </ul>
            
            <h3>3. 编译时vs运行时</h3>
            <ul>
                <li><strong>静态语言</strong>：大部分工作在编译时完成</li>
                <li><strong>动态语言</strong>：大量工作在运行时进行</li>
            </ul>
            
            <h2>判断标准</h2>
            <p>判断一门语言是否是"汇编封装"应该考虑：</p>
            <ol>
                <li>语言语义是否直接映射到机器概念</li>
                <li>是否需要运行时系统支持</li>
                <li>编译器是否进行深度优化和转换</li>
                <li>是否有复杂的内存管理机制</li>
            </ol>
        </div>
        
        <!-- 第6页：总结 -->
        <div class="page" id="page6">
            <h1>总结：准确理解C/C++与汇编的关系</h1>
            
            <h2>核心结论</h2>
            <div class="key-point">
                <p><strong>C语言</strong>：可以看作"可移植的、结构化的高级汇编"，提供了接近硬件的控制能力，但仍然是一门独立的高级语言。</p>
            </div>
            
            <div class="key-point">
                <p><strong>C++语言</strong>：在C之上构建了大量与机器无关的抽象层，包括面向对象、泛型编程、异常处理等，离汇编更远。</p>
            </div>
            
            <div class="key-point">
                <p><strong>编译过程</strong>：现代编译器不是简单的翻译器，而是复杂的优化系统，可能完全改变代码的结构和逻辑。</p>
            </div>
            
            <h2>为什么"封装汇编"的说法不准确？</h2>
            <ol>
                <li><strong>忽略抽象层次</strong>：C/C++建立了多层抽象，每层都有独立语义</li>
                <li><strong>简化编译器作用</strong>：编译器进行深度优化，不是一对一映射</li>
                <li><strong>混淆实现与定义</strong>：语言语义不等于最终机器码</li>
                <li><strong>缺乏历史视角</strong>：不了解语言设计的历史背景和目标</li>
            </ol>
            
            <h2>更准确的描述</h2>
            <h3>对于C语言：</h3>
            <ul>
                <li>"系统编程语言"</li>
                <li>"可移植的汇编"</li>
                <li>"结构化的低级语言"</li>
                <li>"Unix的母语"</li>
            </ul>
            
            <h3>对于C++语言：</h3>
            <ul>
                <li>"多范式系统编程语言"</li>
                <li>"带类的C"</li>
                <li>"零开销抽象的语言"</li>
                <li>"现代系统编程的瑞士军刀"</li>
            </ul>
            
            <h2>实践意义</h2>
            <h3>1. 理解性能优化</h3>
            <p>正确理解编译过程有助于写出性能更好的代码，知道哪些优化编译器会做，哪些需要手动干预。</p>
            
            <h3>2. 调试和问题定位</h3>
            <p>了解抽象层次有助于在不同层级调试问题，从应用层到汇编层。</p>
            
            <h3>3. 语言选择</h3>
            <p>根据项目需求选择合适的语言，理解每种语言的抽象层次和适用场景。</p>
            
            <h2>未来展望</h2>
            <ul>
                <li><strong>Rust</strong>：提供C++级别的性能，但增加内存安全保证</li>
                <li><strong>WebAssembly</strong>：新的编译目标，介于高级语言和机器码之间</li>
                <li><strong>量子计算</strong>：全新的计算模型，需要新的抽象层次</li>
            </ul>
            
            <h2>最终思考</h2>
            <p>编程语言的设计是在<span class="highlight">抽象能力</span>和<span class="highlight">控制精度</span>之间的权衡。C/C++在这个谱系中偏向控制精度，但仍然提供了重要的抽象。将它们简单称为"汇编封装"既不尊重语言设计的复杂性，也无助于理解现代软件系统的构建。</p>
            
            <div class="flow-diagram">
                <strong>抽象谱系：</strong><br>
                机器码 ← 汇编 ← C ← C++ ← Java/Python ← 领域特定语言
            </div>
        </div>
    </div>
    
    <!-- 导航控制 -->
    <div class="navigation">
        <button class="nav-btn" id="prevBtn" onclick="changePage(-1)">上一页</button>
        <div class="page-indicator">
            <span class="dot active" data-page="1"></span>
            <span class="dot" data-page="2"></span>
            <span class="dot" data-page="3"></span>
            <span class="dot" data-page="4"></span>
            <span class="dot" data-page="5"></span>
            <span class="dot" data-page="6"></span>
        </div>
        <button class="nav-btn" id="nextBtn" onclick="changePage(1)">下一页</button>
    </div>
    
    <script>
        let currentPage = 1;
        const totalPages = 6;
        
        function showPage(pageNum) {
            // 隐藏所有页面
            document.querySelectorAll('.page').forEach(page => {
                page.classList.remove('active');
            });
            
            // 显示当前页面
            document.getElementById(`page${pageNum}`).classList.add('active');
            
            // 更新导航按钮状态
            document.getElementById('prevBtn').disabled = pageNum === 1;
            document.getElementById('nextBtn').disabled = pageNum === totalPages;
            
            // 更新页面指示器
            document.querySelectorAll('.dot').forEach(dot => {
                dot.classList.remove('active');
                if (parseInt(dot.dataset.page) === pageNum) {
                    dot.classList.add('active');
                }
            });
            
            currentPage = pageNum;
        }
        
        function changePage(direction) {
            const newPage = currentPage + direction;
            if (newPage >= 1 && newPage <= totalPages) {
                showPage(newPage);
            }
        }
        
        // 触摸滑动支持
        let touchStartX = 0;
        let touchEndX = 0;
        
        document.addEventListener('touchstart', e => {
            touchStartX = e.changedTouches[0].screenX;
        });
        
        document.addEventListener('touchend', e => {
            touchEndX = e.changedTouches[0].screenX;
            handleSwipe();
        });
        
        function handleSwipe() {
            const swipeThreshold = 50;
            const diff = touchStartX - touchEndX;
            
            if (Math.abs(diff) > swipeThreshold) {
                if (diff > 0) {
                    // 向左滑动，下一页
                    changePage(1);
                } else {
                    // 向右滑动，上一页
                    changePage(-1);
                }
            }
        }
        
        // 键盘导航
        document.addEventListener('keydown', e => {
            if (e.key === 'ArrowLeft') {
                changePage(-1);
            } else if (e.key === 'ArrowRight') {
                changePage(1);
            }
        });
        
        // 点击页面指示器跳转
        document.querySelectorAll('.dot').forEach(dot => {
            dot.addEventListener('click', () => {
                showPage(parseInt(dot.dataset.page));
            });
        });
    </script>
</body>
</html>