Chemmy's Blog

chengming0916@outlook.com

发表于 更新于

一、 核心概念：Ports 与 Packages

FreeBSD 提供了两种安装第三方软件的方式：

方式 描述 特点
Ports Collection 从源代码编译安装。 高度可定制（可启用/禁用功能），但编译耗时。
Packages (pkg) 安装预编译的二进制包。 快速、便捷，是管理附加软件的首选方式。

关键路径差异：通过 pkg 安装的软件，其二进制文件和大多数配置文件位于 /usr/local/ 目录下（例如 /usr/local/bin, /usr/local/etc），这与 Linux 发行版常见的 /usr/ 和 /etc 不同。

二、 安装与初始配置

1. 安装 pkg 工具

在全新的 FreeBSD 系统上，pkg 工具本身并未预装。首次使用任何 pkg 命令（如 pkg install）时，系统会提示你安装它：

1
2
3
pkg install wget
# 输出：The package management tool is not yet installed...
# 输入 `y` 确认安装。

也可以直接运行以下命令来引导安装：

1
pkg bootstrap
2. 配置文件 (/usr/local/etc/pkg.conf)

pkg 的行为可通过此文件进行全局定制。文件采用 UCL 格式，包含大量注释说明。

  • 常用配置项：
    • ASSUME_ALWAYS_YES: true：默认对所有确认提示回答“是”，适用于脚本。
    • AUTOCLEAN: true：安装/升级后自动清理过时的缓存包。
  • 定义命令别名：在文件底部的 ALIAS 部分，可以为常用命令组合创建快捷方式。
  • 查看手册：man pkg.conf

三、 日常包管理操作

1. 搜索软件包

在安装前，需要确定软件包的正确名称。

1
2
3
4
5
6
# 基本搜索（在包名和描述中查找）
pkg search apache

# 精确搜索并显示详细信息
pkg search -R apache24
# 输出包括：包名、版本、维护者、描述、依赖等。
2. 安装与卸载
1
2
3
4
5
6
7
8
9
10
# 安装软件包（及其依赖）
pkg install apache24

# 安装时不询问确认（适用于脚本）
pkg install -y nginx

# 卸载软件包
pkg delete nginx
# 或
pkg remove nginx

注意：卸载一个被其他包依赖的包时，依赖包也会被一同卸载。

3. 查询已安装的包
1
2
3
4
5
6
7
8
9
10
11
# 列出所有已安装的包
pkg info

# 查看特定包的详细信息
pkg info nginx

# 列出特定包安装的文件
pkg info -l nginx

# 查询某个文件由哪个包提供
pkg which /usr/local/bin/curl
4. 更新与升级
1
2
3
4
5
6
7
8
# 更新本地包仓库目录（非升级软件）
pkg update

# 升级所有已安装的包到最新版本
pkg upgrade

# 升级特定包
pkg upgrade nginx

四、 高级管理与维护

1. 包缓存管理

pkg 会将下载的包文件缓存到 /var/cache/pkg。

1
2
3
4
5
6
7
8
9
10
11
12
13
# 仅下载包而不安装（可用于离线安装）
pkg fetch nginx
# 下载包及其所有依赖
pkg fetch -d nginx

# 清理已被新版替换的旧缓存包
pkg clean

# 清理所有缓存包
pkg clean -a

# 列出缓存内容
ls /var/cache/pkg
2. 锁定与解锁包

防止特定包被意外升级或删除。

1
2
3
4
5
6
7
8
9
10
11
12
# 锁定一个包
pkg lock openssl

# 列出所有被锁定的包
pkg lock -l

# 解锁一个包
pkg unlock openssl

# 锁定/解锁所有包
pkg lock -a
pkg unlock -a
3. 依赖与自动清理
1
2
3
4
5
# 移除不再被任何包依赖的“孤儿”包（自动包）
pkg autoremove

# 查看哪些包是手动安装的（非自动依赖）
pkg prime-list
4. 安全检查与验证
1
2
3
4
5
6
7
8
# 检查所有已安装包是否有已知安全漏洞
pkg audit -F

# 验证所有包的完整性
pkg check -saq

# 验证特定包的文件是否被修改
pkg check -s nginx

五、 包仓库（Repository）配置

FreeBSD 的官方包仓库配置在 /etc/pkg/FreeBSD.conf。默认使用 quarterly 分支，更稳定。

1
2
3
4
FreeBSD: {
  url: "pkg+http://pkg.FreeBSD.org/${ABI}/quarterly",
  enabled: yes
}
  • 切换分支：将 url 中的 quarterly 改为 latest 可获取最新的软件包（可能包含测试版）。
  • 添加第三方仓库：在 /usr/local/etc/pkg/repos/ 目录下创建 .conf 文件。需确保 pkg.conf 中 REPO_DIRS 包含该路径。

六、 命令速查与参考

任务 命令
安装 pkg install <包名>
卸载 pkg delete <包名>
搜索 pkg search <关键词>
列表 pkg info
更新仓库 pkg update
升级系统 pkg upgrade
清理缓存 pkg clean
自动移除孤儿包 pkg autoremove
安全检查 pkg audit -F
锁定包 pkg lock <包名>
获取帮助 pkg help <子命令>

七、 重要文件与目录

路径 用途
/usr/local/etc/pkg.conf pkg 主配置文件
/etc/pkg/FreeBSD.conf 官方 FreeBSD 包仓库配置
/usr/local/etc/pkg/repos/ 自定义第三方仓库配置目录
/var/cache/pkg/ 下载的包文件缓存目录
/var/db/pkg/local.sqlite 已安装包的注册数据库（切勿删除）
/usr/local/ 通过 pkg 安装的软件根目录

总结：对于绝大多数 FreeBSD 系统管理任务，pkg 是管理第三方软件最有效、最推荐的工具。除非你需要特定的编译选项或软件尚未被打包，否则应优先使用 pkg 而非 Ports。

发表于 更新于 分类于 ，

前言

算法这个东西其实在开发中很少用到，特别是web开发中，但是算法也很重要，因为任何的程序，任何的软件，都是由很多的算法和数据结构组成的。但是这不意味着算法对于每个软件设计人员的实际工作都是很重要的。每个项目特点和需求特殊也导致算法运用场景上不同。但是个人觉得算法运用的好的话会给自己在程序设计的时候提供比较好的思路。下面就对一些排序算法小结一下，就当做自己的一个笔记吧。

插入排序

1.简介

插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

2.算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果该元素（已排序）大于新元素，将该元素移到下一位置
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置后
6.重复步骤2~5
如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找排序。

3.使用插入排序为一列数字进行排序的过程 

最差时间复杂度 O(n^{2})

最优时间复杂度 O(n)

平均时间复杂度O(n^{2})

4.C#实现

复制代码

    /// <summary>
    /// 插入排序 /// </summary>
    public class InsertionSorter
    { public void Sort(int\[\] list)
        { for (int i = 1; i < list.Length; ++i)
            { int t = list\[i\]; int j = i; while ((j > 0) && (list\[j - 1\] > t))
                {
                    list\[j\] \= list\[j - 1\]; \--j;
                }
                list\[j\] \= t;
            }

        }
    }

复制代码

数组

int[] iArrary = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };

希尔排序

1.简介

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

2.算法实现

原始的算法实现在最坏的情况下需要进行O(n2)的比较和交换。V. Pratt的书[1] 对算法进行了少量修改，可以使得性能提升至O(n log2 n)。这比最好的比较算法的O(n log n)要差一些。
希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。
假设有一个很小的数据在一个已按升序排好序的数组的末端。如果用复杂度为O(n2)的排序（冒泡排序或插入排序），可能会进行n次的比较和交换才能将该数据移至正确位置。而希尔排序会用较大的步长移动数据，所以小数据只需进行少数比较和交换即可到正确位置。
一个更好理解的希尔排序实现：将数组列在一个表中并对列排序（用插入排序）。重复这过程，不过每次用更长的列来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身仅仅对原数组进行排序（通过增加索引的步长，例如是用i += step_size而不是i++）。

3.排序过程

最差时间复杂度 根据步长串行的不同而不同。O(n\log^2 n)

最优时间复杂度 O(n)

平均时间复杂度  根据步长串行的不同而不同。

4.C#实现

复制代码

    /// <summary>
    /// 希尔排序 /// </summary>
    public class ShellSorter
    { public void Sort(int\[\] list)
        { int inc; for (inc = 1; inc <= list.Length / 9; inc = 3 \* inc + 1) ; for (; inc > 0; inc /= 3)
            { for (int i = inc + 1; i <= list.Length; i += inc)
                { int t = list\[i - 1\]; int j = i; while ((j > inc) && (list\[j - inc - 1\] > t))
                    {
                        list\[j \- 1\] = list\[j - inc - 1\];
                        j \-= inc;
                    }
                    list\[j \- 1\] = t;
                }
            }
        }
    }

复制代码

选择排序

 1.简介

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

2.实现过程

最差时间复杂度 О(n²)

最优时间复杂度 О(n²)

平均时间复杂度 О(n²)

3.C#实现

复制代码

    /// <summary>
    /// 选择排序 /// </summary>
    public class SelectionSorter
    { // public enum comp {COMP\_LESS,COMP\_EQUAL,COMP\_GRTR};
        private int min; // private int m=0;
        public void Sort(int\[\] list)
        { for (int i = 0; i < list.Length - 1; ++i)
            {
                min \= i; for (int j = i + 1; j < list.Length; ++j)
                { if (list\[j\] < list\[min\])
                        min \= j;
                } int t = list\[min\];
                list\[min\] \= list\[i\];
                list\[i\] \= t; // Console.WriteLine("{0}",list\[i\]);

}

        }
    }

复制代码

冒泡排序

1.简介

冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序对n个项目需要O(n^{2})的比较次数，且可以原地排序。尽管这个算法是最简单了解和实作的排序算法之一，但它对于少数元素之外的数列排序是很没有效率的。
冒泡排序是与插入排序拥有相等的执行时间，但是两种法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要O(n^{2})次交换，而插入排序只要最多O(n)交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地执行（O(n^{2})），而插入排序在这个例子只需要O(n)个运算。因此很多现代的算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部循环第一次执行时，使用一个旗标来表示有无需要交换的可能，也有可能把最好的复杂度降低到O(n)。在这个情况，在已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序和比较大小反过来，也可以稍微地改进效率。有时候称为往返排序，因为算法会从数列的一端到另一端之间穿梭往返。

2.算法实现
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

3.实现过程

最差时间复杂度 O(n^{2})

最优时间复杂度 O(n)

平均时间复杂度 O(n^{2})

4.C#实现

复制代码

   /// <summary>
    /// 冒泡排序 /// </summary>
    public class bubblesort
    { public void BubbleSort(int\[\] R)
        { int i, j, temp; //交换标志 
            bool exchange; for (i = 0; i < R.Length; i++) //最多做R.Length-1趟排序

{
exchange = false; //本趟排序开始前，交换标志应为假
for (j = R.Length - 2; j >= i; j–)
{ if (R[j + 1] < R[j])　//交换条件
{
temp = R[j + 1];
R[j + 1] = R[j];
R[j] = temp;
exchange = true; //发生了交换，故将交换标志置为真
}
} if (!exchange) //本趟排序未发生交换，提前终止算法
{ break;
}
}
}
}

复制代码

发表于 更新于 分类于 ，

8种主要排序算法的C#实现

Excerpt

8种主要排序算法的实现及优化，包含选择排序，冒泡排序，插入排序，快速排序，归并排序，堆排序，希尔排序，基数排序。文末实际测试并比较。

新的一年到了，很多园友都辞职要去追求更好的工作环境，我也是其中一个，呵呵！

最近闲暇的时候我开始重温一些常用的算法。老早就买了《算法导论》，一直都没啃下去。

这本书确实很好，只是太难读了，总是读了几章就又读不下去了！工作上也几乎用不到。

我这段时间发现看这些排序算法比以前容易了很多，就借此机会将它们整理总结起来。

一是方便以后重温，二是可以应对笔试面试。同时也希望这篇博文可以帮助各位刚辞职和正在学习排序算法的园友。

PS：有可能实现的代码并不是最优的，如果有什么错误或者值得改进的地方，还请大家帮忙指出。

简介

排序算法是我们编程中遇到的最多的算法。目前主流的算法有8种。

  平均时间复杂度从高到低依次是：

     冒泡排序（o(n2)），选择排序（o(n2)），插入排序（o(n2)），堆排序（o(nlogn)），

     归并排序（o(nlogn)），快速排序（o(nlogn)）， 希尔排序（o(n1.25)），基数排序（o(n)）

这些平均时间复杂度是参照维基百科排序算法罗列的。

是计算的理论平均值，并不意味着你的代码实现能达到这样的程度。

例如希尔排序，时间复杂度是由选择的步长决定的。基数排序时间复杂度最小，

但我实现的基数排序的速度并不是最快的，后面的结果测试图可以看到。

本文代码实现使用的数据源类型为IList，这样可以兼容int[]和List(虽然int[]有ToList()，

List有ToArray()，哈哈！)。

选择排序

选择排序是我觉得最简单暴力的排序方式了。

以前刚接触排序算法的时候，感觉算法太多搞不清，唯独记得选择排序的做法及实现。

原理：找出参与排序的数组最大值，放到末尾（或找到最小值放到开头） 维基入口

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> SelectSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; data.Count - <span>1</span>; i++<span>)
</span><span> 4</span> <span>            {
</span><span> 5</span>                 <span>int</span> min =<span> i;
</span><span> 6</span>                 <span>int</span> temp =<span> data[i];
</span><span> 7</span>                 <span>for</span> (<span>int</span> j = i + <span>1</span>; j &lt; data.Count; j++<span>)
</span><span> 8</span> <span>                {
</span><span> 9</span>                     <span>if</span> (data[j] &lt;<span> temp)
</span><span>10</span> <span>                    {
</span><span>11</span>                         min =<span> j;
</span><span>12</span>                         temp =<span> data[j];
</span><span>13</span> <span>                    }
</span><span>14</span> <span>                }
</span><span>15</span>                 <span>if</span> (min !=<span> i)
</span><span>16</span> <span>                    Swap(data, min, i);
</span><span>17</span> <span>            }
</span><span>18</span>         }

复制代码

过程解析：将剩余数组的最小数交换到开头。

冒泡排序

冒泡排序是笔试面试经常考的内容，虽然它是这些算法里排序速度最慢的（汗），后面有测试为证。

原理：从头开始，每一个元素和它的下一个元素比较，如果它大，就将它与比较的元素交换，否则不动。

这意味着，大的元素总是在向后慢慢移动直到遇到比它更大的元素。所以每一轮交换完成都能将最大值

冒到最后。  维基入口

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> BubbleSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>for</span> (<span>int</span> i = data.Count - <span>1</span>; i &gt; <span>0</span>; i--<span>)
</span><span> 4</span> <span>            {
</span><span> 5</span>                 <span>for</span> (<span>int</span> j = <span>0</span>; j &lt; i; j++<span>)
</span><span> 6</span> <span>                {
</span><span> 7</span>                     <span>if</span> (data[j] &gt; data[j + <span>1</span><span>])
</span><span> 8</span>                         Swap(data, j, j + <span>1</span><span>);
</span><span> 9</span> <span>                }
</span><span>10</span> <span>            }
</span><span>11</span>         }

复制代码

过程解析：中需要注意的是j<i，每轮冒完泡必然会将最大值排到数组末尾，所以需要排序的数应该是在减少的。

很多网上版本每轮冒完泡后依然还是将所有的数进行第二轮冒泡即j<data.Count-1，这样会增加比较次数。

通过标识提升冒泡排序

在维基上看到，可以通过添加标识来分辨剩余的数是否已经有序来减少比较次数。感觉很有意思，可以试试。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> BubbleSortImprovedWithFlag(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>bool</span><span> flag;
</span><span> 4</span>             <span>for</span> (<span>int</span> i = data.Count - <span>1</span>; i &gt; <span>0</span>; i--<span>)
</span><span> 5</span> <span>            {
</span><span> 6</span>                 flag = <span>true</span><span>;
</span><span> 7</span>                 <span>for</span> (<span>int</span> j = <span>0</span>; j &lt; i; j++<span>)
</span><span> 8</span> <span>                {
</span><span> 9</span>                     <span>if</span> (data[j] &gt; data[j + <span>1</span><span>])
</span><span>10</span> <span>                    {
</span><span>11</span>                         Swap(data, j, j + <span>1</span><span>);
</span><span>12</span>                         flag = <span>false</span><span>;
</span><span>13</span> <span>                    }
</span><span>14</span> <span>                }
</span><span>15</span>                 <span>if</span> (flag) <span>break</span><span>;
</span><span>16</span> <span>            }
</span><span>17</span>         }

复制代码

过程解析：发现某轮冒泡没有任何数进行交换（即已经有序），就跳出排序。

我起初也以为这个方法是应该有不错效果的，可是实际测试结果并不如想的那样。和未优化耗费时间一样（对于随机数列）。

由果推因，那么应该是冒泡排序对于随机数列，当剩余数列有序的时候，也没几个数要排列了！？

不过如果已经是有序数列或者部分有序的话，这个冒泡方法将会提升很大速度。

鸡尾酒排序（来回排序）

对冒泡排序进行更大的优化

冒泡排序只是单向冒泡，而鸡尾酒来回反复双向冒泡。

原理：自左向右将大数冒到末尾，然后将剩余数列再自右向左将小数冒到开头，如此循环往复。维基入口

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> BubbleCocktailSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>bool</span><span> flag;
</span><span> 4</span>             <span>int</span> m = <span>0</span>, n = <span>0</span><span>;
</span><span> 5</span>             <span>for</span> (<span>int</span> i = data.Count - <span>1</span>; i &gt; <span>0</span>; i--<span>)
</span><span> 6</span> <span>            {
</span><span> 7</span>                 flag = <span>true</span><span>;
</span><span> 8</span>                 <span>if</span> (i % <span>2</span> == <span>0</span><span>)
</span><span> 9</span> <span>                {
</span><span>10</span>                     <span>for</span> (<span>int</span> j = n; j &lt; data.Count - <span>1</span> - m; j++<span>)
</span><span>11</span> <span>                    {
</span><span>12</span>                         <span>if</span> (data[j] &gt; data[j + <span>1</span><span>])
</span><span>13</span> <span>                        {
</span><span>14</span>                             Swap(data, j, j + <span>1</span><span>);
</span><span>15</span>                             flag = <span>false</span><span>;
</span><span>16</span> <span>                        }
</span><span>17</span> <span>                    }
</span><span>18</span>                     <span>if</span> (flag) <span>break</span><span>;
</span><span>19</span>                     m++<span>;
</span><span>20</span> <span>                }
</span><span>21</span>                 <span>else</span>
<span>22</span> <span>                {
</span><span>23</span>                     <span>for</span> (<span>int</span> k = data.Count - <span>1</span> - m; k &gt; n; k--<span>)
</span><span>24</span> <span>                    {
</span><span>25</span>                         <span>if</span> (data[k] &lt; data[k - <span>1</span><span>])
</span><span>26</span> <span>                        {
</span><span>27</span>                             Swap(data, k, k - <span>1</span><span>);
</span><span>28</span>                             flag = <span>false</span><span>;
</span><span>29</span> <span>                        }
</span><span>30</span> <span>                    }
</span><span>31</span>                     <span>if</span> (flag) <span>break</span><span>;
</span><span>32</span>                     n++<span>;
</span><span>33</span> <span>                }
</span><span>34</span> <span>            }
</span><span>35</span>         }

复制代码

过程解析：分析第i轮冒泡，i是偶数则将剩余数列最大值向右冒泡至末尾，是奇数则将剩余数列最小值

向左冒泡至开头。对于剩余数列，n为始，data.Count-1-m为末。

来回冒泡比单向冒泡：对于随机数列，更容易得到有序的剩余数列。因此这里使用标识将会提升的更加明显。

插入排序

插入排序是一种对于有序数列高效的排序。非常聪明的排序。只是对于随机数列，效率一般，交换的频率高。

原理：通过构建有序数列，将未排序的数从后向前比较，找到合适位置并插入。维基入口

第一个数当作有序数列。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> InsertSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span><span> temp;
</span><span> 4</span>             <span>for</span> (<span>int</span> i = <span>1</span>; i &lt; data.Count; i++<span>)
</span><span> 5</span> <span>            {
</span><span> 6</span>                 temp =<span> data[i];
</span><span> 7</span>                 <span>for</span> (<span>int</span> j = i - <span>1</span>; j &gt;= <span>0</span>; j--<span>)
</span><span> 8</span> <span>                {
</span><span> 9</span>                     <span>if</span> (data[j] &gt;<span> temp)
</span><span>10</span> <span>                    {
</span><span>11</span>                         data[j + <span>1</span>] =<span> data[j];
</span><span>12</span>                         <span>if</span> (j == <span>0</span><span>)
</span><span>13</span> <span>                        {
</span><span>14</span>                             data[<span>0</span>] =<span> temp;
</span><span>15</span>                             <span>break</span><span>;
</span><span>16</span> <span>                        }
</span><span>17</span> <span>                    }
</span><span>18</span>                     <span>else</span>
<span>19</span> <span>                    {
</span><span>20</span>                         data[j + <span>1</span>] =<span> temp;
</span><span>21</span>                         <span>break</span><span>;
</span><span>22</span> <span>                    }
</span><span>23</span> <span>                }
</span><span>24</span> <span>            }
</span><span>25</span>         }

复制代码

过程解析：将要排序的数（索引为i）存储起来，向前查找合适位置j+1，将i-1到j+1的元素依次向后

移动一位，空出j+1，然后将之前存储的值放在这个位置。

这个方法写的不如维基上的简洁清晰，由于合适位置是j+1所以多出了对j==0的判断，但实际效率影响无差别。

建议比照维基和我写的排序，自行选择。

二分查找法优化插入排序

插入排序主要工作是在有序的数列中对要排序的数查找合适的位置，而查找里面经典的二分查找法正可以适用。

原理：通过二分查找法的方式找到一个位置索引。当要排序的数插入这个位置时，大于前一个数，小于后一个数。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> InsertSortImprovedWithBinarySearch(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span><span> temp;
</span><span> 4</span>             <span>int</span><span> tempIndex;
</span><span> 5</span>             <span>for</span> (<span>int</span> i = <span>1</span>; i &lt; data.Count; i++<span>)
</span><span> 6</span> <span>            {
</span><span> 7</span>                 temp =<span> data[i];
</span><span> 8</span>                 tempIndex = BinarySearchForInsertSort(data, <span>0</span><span>, i, i);
</span><span> 9</span>                 <span>for</span> (<span>int</span> j = i - <span>1</span>; j &gt;= tempIndex; j--<span>)
</span><span>10</span> <span>                {
</span><span>11</span>                     data[j + <span>1</span>] =<span> data[j];
</span><span>12</span> <span>                }
</span><span>13</span>                 data[tempIndex] =<span> temp;
</span><span>14</span> <span>            }
</span><span>15</span> <span>        }
</span><span>16</span> 
<span>17</span>         <span>public</span> <span>static</span> <span>int</span> BinarySearchForInsertSort(IList&lt;<span>int</span>&gt; data, <span>int</span> low, <span>int</span> high, <span>int</span><span> key)
</span><span>18</span> <span>        {
</span><span>19</span>             <span>if</span> (low &gt;= data.Count - <span>1</span><span>)
</span><span>20</span>                 <span>return</span> data.Count - <span>1</span><span>;
</span><span>21</span>             <span>if</span> (high &lt;= <span>0</span><span>)
</span><span>22</span>                 <span>return</span> <span>0</span><span>;
</span><span>23</span>             <span>int</span> mid = (low + high) / <span>2</span><span>;
</span><span>24</span>             <span>if</span> (mid == key) <span>return</span><span> mid;
</span><span>25</span>             <span>if</span> (data[key] &gt;<span> data[mid])
</span><span>26</span> <span>            {
</span><span>27</span>                 <span>if</span> (data[key] &lt; data[mid + <span>1</span><span>])
</span><span>28</span>                     <span>return</span> mid + <span>1</span><span>;
</span><span>29</span>                 <span>return</span> BinarySearchForInsertSort(data, mid + <span>1</span><span>, high, key);
</span><span>30</span> <span>            }
</span><span>31</span>             <span>else  <span>// data[key] &lt;= data[mid]</span></span>
<span>32</span> <span>            {
</span><span>33</span>                 <span>if</span> (mid - <span>1</span> &lt; <span>0</span>) <span>return</span> <span>0</span><span>;
</span><span>34</span>                 <span>if</span> (data[key] &gt; data[mid - <span>1</span><span>])
</span><span>35</span>                     <span>return</span><span> mid;
</span><span>36</span>                 <span>return</span> BinarySearchForInsertSort(data, low, mid - <span>1</span><span>, key);
</span><span>37</span> <span>            }
</span><span>38</span>         }

复制代码

 过程解析：需要注意的是二分查找方法实现中high-low==1的时候mid==low，所以需要33行

mid-1<0即mid==0的判断，否则下行会索引越界。

快速排序

快速排序是一种有效比较较多的高效排序。它包含了“分而治之”以及“哨兵”的思想。

原理：从数列中挑选一个数作为“哨兵”，使比它小的放在它的左侧，比它大的放在它的右侧。将要排序是数列递归地分割到

最小数列，每次都让分割出的数列符合“哨兵”的规则，自然就将数列变得有序。 维基入口

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> QuickSortStrict(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             QuickSortStrict(data, <span>0</span>, data.Count - <span>1</span><span>);
</span><span> 4</span> <span>        }
</span><span> 5</span> 
<span> 6</span>         <span>public</span> <span>static</span> <span>void</span> QuickSortStrict(IList&lt;<span>int</span>&gt; data, <span>int</span> low, <span>int</span><span> high)
</span><span> 7</span> <span>        {
</span><span> 8</span>             <span>if</span> (low &gt;= high) <span>return</span><span>;
</span><span> 9</span>             <span>int</span> temp =<span> data[low];
</span><span>10</span>             <span>int</span> i = low + <span>1</span>, j =<span> high;
</span><span>11</span>             <span>while</span> (<span>true</span><span>)
</span><span>12</span> <span>            {
</span><span>13</span>                 <span>while</span> (data[j] &gt; temp) j--<span>;
</span><span>14</span>                 <span>while</span> (data[i] &lt; temp &amp;&amp; i &lt; j) i++<span>;
</span><span>15</span>                 <span>if</span> (i &gt;= j) <span>break</span><span>;
</span><span>16</span> <span>                Swap(data, i, j);
</span><span>17</span>                 i++; j--<span>;
</span><span>18</span> <span>            }
</span><span>19</span>             <span>if</span> (j !=<span> low)
</span><span>20</span> <span>                Swap(data, low, j);
</span><span>21</span>             QuickSortStrict(data, j + <span>1</span><span>, high);
</span><span>22</span>             QuickSortStrict(data, low, j - <span>1</span><span>);
</span><span>23</span>         }

复制代码

过程解析：取的哨兵是数列的第一个值，然后从第二个和末尾同时查找，左侧要显示的是小于哨兵的值，

所以要找到不小于的i，右侧要显示的是大于哨兵的值，所以要找到不大于的j。将找到的i和j的数交换，

这样可以减少交换次数。i>=j时，数列全部查找了一遍，而不符合条件j必然是在小的那一边，而哨兵

是第一个数，位置本应是小于自己的数。所以将哨兵与j交换，使符合“哨兵”的规则。

这个版本的缺点在于如果是有序数列排序的话，递归次数会很可怕的。

另一个版本

这是维基上的一个C#版本，我觉得很有意思。这个版本并没有严格符合“哨兵”的规则。但却将“分而治之”

以及“哨兵”思想融入其中，代码简洁。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> QuickSortRelax(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             QuickSortRelax(data, <span>0</span>, data.Count - <span>1</span><span>);
</span><span> 4</span> <span>        }
</span><span> 5</span> 
<span> 6</span>         <span>public</span> <span>static</span> <span>void</span> QuickSortRelax(IList&lt;<span>int</span>&gt; data, <span>int</span> low, <span>int</span><span> high)
</span><span> 7</span> <span>        {
</span><span> 8</span>             <span>if</span> (low &gt;= high) <span>return</span><span>;
</span><span> 9</span>             <span>int</span> temp = data[(low + high) / <span>2</span><span>];
</span><span>10</span>             <span>int</span> i = low - <span>1</span>, j = high + <span>1</span><span>;
</span><span>11</span>             <span>while</span> (<span>true</span><span>)
</span><span>12</span> <span>            {
</span><span>13</span>                 <span>while</span> (data[++i] &lt;<span> temp) ;
</span><span>14</span>                 <span>while</span> (data[--j] &gt;<span> temp) ;
</span><span>15</span>                 <span>if</span> (i &gt;= j) <span>break</span><span>;
</span><span>16</span> <span>                Swap(data, i, j);
</span><span>17</span> <span>            }
</span><span>18</span>             QuickSortRelax(data, j + <span>1</span><span>, high);
</span><span>19</span>             QuickSortRelax(data, low, i - <span>1</span><span>);
</span><span>20</span>         }

复制代码

过程解析：取的哨兵是数列中间的数。将数列分成两波，左侧小于等于哨兵，右侧大于等于哨兵。

也就是说，哨兵不一定处于两波数的中间。虽然哨兵不在中间，但不妨碍“哨兵”的思想的实现。所以

这个实现也可以达到快速排序的效果。但却造成了每次递归完成，要排序的数列数总和没有减少（除非i==j）。

针对这个版本的缺点，我进行了优化

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> QuickSortRelaxImproved(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             QuickSortRelaxImproved(data, <span>0</span>, data.Count - <span>1</span><span>);
</span><span> 4</span> <span>        }
</span><span> 5</span> 
<span> 6</span>         <span>public</span> <span>static</span> <span>void</span> QuickSortRelaxImproved(IList&lt;<span>int</span>&gt; data, <span>int</span> low, <span>int</span><span> high)
</span><span> 7</span> <span>        {
</span><span> 8</span>             <span>if</span> (low &gt;= high) <span>return</span><span>;
</span><span> 9</span>             <span>int</span> temp = data[(low + high) / <span>2</span><span>];
</span><span>10</span>             <span>int</span> i = low - <span>1</span>, j = high + <span>1</span><span>;
</span><span>11</span>             <span>int</span> index = (low + high) / <span>2</span><span>;
</span><span>12</span>             <span>while</span> (<span>true</span><span>)
</span><span>13</span> <span>            {
</span><span>14</span>                 <span>while</span> (data[++i] &lt;<span> temp) ;
</span><span>15</span>                 <span>while</span> (data[--j] &gt;<span> temp) ;
</span><span>16</span>                 <span>if</span> (i &gt;= j) <span>break</span><span>;
</span><span>17</span> <span>                Swap(data, i, j);
</span><span>18</span>                 <span>if</span> (i == index) index =<span> j;
</span><span>19</span>                 <span>else</span> <span>if</span> (j == index) index =<span> i;
</span><span>20</span> <span>            }
</span><span>21</span>             <span>if</span> (j ==<span> i)
</span><span>22</span> <span>            {
</span><span>23</span>                 QuickSortRelaxImproved(data, j + <span>1</span><span>, high);
</span><span>24</span>                 QuickSortRelaxImproved(data, low, i - <span>1</span><span>);
</span><span>25</span> <span>            }
</span><span>26</span>             <span>else</span> <span>//</span><span>i-j==1</span>
<span>27</span> <span>            {
</span><span>28</span>                 <span>if</span> (index &gt;=<span> i)
</span><span>29</span> <span>                {
</span><span>30</span>                     <span>if</span> (index !=<span> i)
</span><span>31</span> <span>                        Swap(data, index, i);
</span><span>32</span>                     QuickSortRelaxImproved(data, i + <span>1</span><span>, high);
</span><span>33</span>                     QuickSortRelaxImproved(data, low, i - <span>1</span><span>);
</span><span>34</span> <span>                }
</span><span>35</span>                 <span>else <span>//</span><span>index &lt; i</span></span>
<span>36</span> <span>                {
</span><span>37</span>                     <span>if</span> (index !=<span> j)
</span><span>38</span> <span>                        Swap(data, index, j);
</span><span>39</span>                     QuickSortRelaxImproved(data, j + <span>1</span><span>, high);
</span><span>40</span>                     QuickSortRelaxImproved(data, low, j - <span>1</span><span>);
</span><span>41</span> <span>                }
</span><span>42</span> <span>            }
</span><span>43</span>         }

复制代码

过程解析：定义了一个变量Index，来跟踪哨兵的位置。发现哨兵最后在小于自己的那堆，

那就与j交换，否则与i交换。达到每次递归都能减少要排序的数列数总和的目的。

归并排序

归并排序也是采用“分而治之”的方式。刚发现分治法是一种算法范式，我还一直以为是一种需要意会的思想呢。

不好意思了，孤陋寡闻了，哈哈！

原理：将两个有序的数列，通过比较，合并为一个有序数列。 维基入口

为方便理解，此处实现用了List的一些方法，随后有IList版本。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<span> 1</span>         <span>public</span> <span>static</span> List&lt;<span>int</span>&gt; MergeSortOnlyList(List&lt;<span>int</span>&gt; data, <span>int</span> low, <span>int</span><span> high)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>if</span> (low ==<span> high)
</span><span> 4</span>                 <span>return</span> <span>new</span> List&lt;<span>int</span>&gt;<span> { data[low] };
</span><span> 5</span>             List&lt;<span>int</span>&gt; mergeData = <span>new</span> List&lt;<span>int</span>&gt;<span>();
</span><span> 6</span>             <span>int</span> mid = (low + high) / <span>2</span><span>;
</span><span> 7</span>             List&lt;<span>int</span>&gt; leftData =<span> MergeSortOnlyList(data, low, mid);
</span><span> 8</span>             List&lt;<span>int</span>&gt; rightData = MergeSortOnlyList(data, mid + <span>1</span><span>, high);
</span><span> 9</span>             <span>int</span> i = <span>0</span>, j = <span>0</span><span>;
</span><span>10</span>             <span>while</span> (<span>true</span><span>)
</span><span>11</span> <span>            {
</span><span>12</span>                 <span>if</span> (leftData[i] &lt;<span> rightData[j])
</span><span>13</span> <span>                {
</span><span>14</span> <span>                    mergeData.Add(leftData[i]);
</span><span>15</span>                     <span>if</span> (++i ==<span> leftData.Count)
</span><span>16</span> <span>                    {
</span><span>17</span>                         mergeData.AddRange(rightData.GetRange(j, rightData.Count -<span> j));
</span><span>18</span>                         <span>break</span><span>;
</span><span>19</span> <span>                    }
</span><span>20</span> <span>                }
</span><span>21</span>                 <span>else</span>
<span>22</span> <span>                {
</span><span>23</span> <span>                    mergeData.Add(rightData[j]);
</span><span>24</span>                     <span>if</span> (++j ==<span> rightData.Count)
</span><span>25</span> <span>                    {
</span><span>26</span>                         mergeData.AddRange(leftData.GetRange(i, leftData.Count -<span> i));
</span><span>27</span>                         <span>break</span><span>;
</span><span>28</span> <span>                    }
</span><span>29</span> <span>                }
</span><span>30</span> <span>            }
</span><span>31</span>             <span>return</span><span> mergeData;
</span><span>32</span> <span>        }
</span><span>33</span> 
<span>34</span>         <span>public</span> <span>static</span> List&lt;<span>int</span>&gt; MergeSortOnlyList(List&lt;<span>int</span>&gt;<span> data)
</span><span>35</span> <span>        {
</span><span>36</span>             data = MergeSortOnlyList(data, <span>0</span>, data.Count - <span>1</span><span>);  <span>//不会改变外部引用 参照<a href="http://www.cnblogs.com/fatbird/p/parametersInCsharp.html" target="_blank">C#参数传递
</a></span></span><span>37</span>             <span>return</span><span> data;
</span><span>38</span>         }

复制代码

过程解析：将数列分为两部分，分别得到两部分数列的有序版本，然后逐个比较，将比较出的小数逐个放进

新的空数列中。当一个数列放完后，将另一个数列剩余数全部放进去。

IList版本

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<span> 1</span>         <span>public</span> <span>static</span> IList&lt;<span>int</span>&gt; MergeSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             data = MergeSort(data, <span>0</span>, data.Count - <span>1</span><span>);
</span><span> 4</span>             <span>return</span><span> data;
</span><span> 5</span> <span>        }
</span><span> 6</span> 
<span> 7</span>         <span>public</span> <span>static</span> IList&lt;<span>int</span>&gt; MergeSort(IList&lt;<span>int</span>&gt; data, <span>int</span> low, <span>int</span><span> high)
</span><span> 8</span> <span>        {
</span><span> 9</span>             <span>int</span> length = high - low + <span>1</span><span>;
</span><span>10</span>             IList&lt;<span>int</span>&gt; mergeData =<span> NewInstance(data, length);
</span><span>11</span>             <span>if</span> (low ==<span> high)
</span><span>12</span> <span>            {
</span><span>13</span>                 mergeData[<span>0</span>] =<span> data[low];
</span><span>14</span>                 <span>return</span><span> mergeData;
</span><span>15</span> <span>            }
</span><span>16</span>             <span>int</span> mid = (low + high) / <span>2</span><span>;
</span><span>17</span>             IList&lt;<span>int</span>&gt; leftData =<span> MergeSort(data, low, mid);
</span><span>18</span>             IList&lt;<span>int</span>&gt; rightData = MergeSort(data, mid + <span>1</span><span>, high);
</span><span>19</span>             <span>int</span> i = <span>0</span>, j = <span>0</span><span>;
</span><span>20</span>             <span>while</span> (<span>true</span><span>)
</span><span>21</span> <span>            {
</span><span>22</span>                 <span>if</span> (leftData[i] &lt;<span> rightData[j])
</span><span>23</span> <span>                {
</span><span>24</span>                     mergeData[i + j] = leftData[i++]; <span>//</span><span>不能使用Add,Array Length不可变</span>
<span>25</span>                     <span>if</span> (i ==<span> leftData.Count)
</span><span>26</span> <span>                    {
</span><span>27</span>                         <span>int</span> rightLeft = rightData.Count -<span> j;
</span><span>28</span>                         <span>for</span> (<span>int</span> m = <span>0</span>; m &lt; rightLeft; m++<span>)
</span><span>29</span> <span>                        {
</span><span>30</span>                             mergeData[i + j] = rightData[j++<span>];
</span><span>31</span> <span>                        }
</span><span>32</span>                         <span>break</span><span>;
</span><span>33</span> <span>                    }
</span><span>34</span> <span>                }
</span><span>35</span>                 <span>else</span>
<span>36</span> <span>                {
</span><span>37</span>                     mergeData[i + j] = rightData[j++<span>];
</span><span>38</span>                     <span>if</span> (j ==<span> rightData.Count)
</span><span>39</span> <span>                    {
</span><span>40</span>                         <span>int</span> leftleft = leftData.Count -<span> i;
</span><span>41</span>                         <span>for</span> (<span>int</span> n = <span>0</span>; n &lt; leftleft; n++<span>)
</span><span>42</span> <span>                        {
</span><span>43</span>                             mergeData[i + j] = leftData[i++<span>];
</span><span>44</span> <span>                        }
</span><span>45</span>                         <span>break</span><span>;
</span><span>46</span> <span>                    }
</span><span>47</span> <span>                }
</span><span>48</span> <span>            }
</span><span>49</span>             <span>return</span><span> mergeData;
</span><span>50</span> 
<span>51</span>         }

复制代码

过程原理与上个一样，此处就不赘述了。

堆排序

堆排序是根据堆这种数据结构设计的一种算法。堆的特性：父节点的值总是小于（或大于）它的子节点。近似二叉树。

原理：将数列构建为最大堆数列（即父节点总是最大值），将最大值（即根节点）交换到数列末尾。这样要排序的数列数总和减少，

同时根节点不再是最大值，调整最大堆数列。如此重复，最后得到有序数列。 维基入口   有趣的演示

实现准备：如何将数列构造为堆——父节点i的左子节点为2i+1，右子节点为2i+2。节点i的父节点为floor((i-1)/2)。

实现如下（这个实现判断和临时变量使用太多，导致效率低，评论中@小城故事提出了更好的实现）：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> HeapSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span> <span>            BuildMaxHeapify(data);
</span><span> 4</span>             <span>int</span> j =<span> data.Count;
</span><span> 5</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt;<span> j; )
</span><span> 6</span> <span>            {
</span><span> 7</span>                 Swap(data, i, --<span>j);
</span><span> 8</span>                 <span>if</span> (j - <span>2</span> &lt; <span>0</span><span>)  <span>//只剩下1个数 j代表余下要排列的数的个数
</span></span><span> 9</span>                     <span>break</span><span>;
</span><span>10</span>                 <span>int</span> k = <span>0</span><span>;
</span><span>11</span>                 <span>while</span> (<span>true</span><span>)
</span><span>12</span> <span>                {
</span><span>13</span>                     <span>if</span> (k &gt; (j - <span>2</span>) / <span>2</span>) <span>break</span><span>;  <span>//即：k &gt; ((j-1)-1)/2</span> <span>超出最后一个父节点的位置  
</span></span><span>14</span>                     <span>else</span>
<span>15</span> <span>                    {
</span><span>16</span>                         <span>int</span> temp =<span> k;
</span><span>17</span>                         k = ReSortMaxBranch(data, k, <span>2</span> * k + <span>1</span>, <span>2</span> * k + <span>2</span>, j - <span>1</span><span>);
</span><span>18</span>                         <span>if</span> (temp == k) <span>break</span><span>;
</span><span>19</span> <span>                    }
</span><span>20</span> <span>                }
</span><span>21</span> <span>            }
</span><span>22</span> <span>        }
</span><span>23</span> 
<span>24</span>         <span>public</span> <span>static</span> <span>void</span> BuildMaxHeapify(IList&lt;<span>int</span>&gt;<span> data)
</span><span>25</span> <span>        {
</span><span>26</span>             <span>for</span> (<span>int</span> i = data.Count / <span>2</span> - <span>1</span>; i &gt;= <span>0</span>; i--<span>)  <span>//(data.Count-1)-1)/2为数列最大父节点索引
</span></span><span>27</span> <span>            {
</span><span>28</span>                 <span>int</span> temp =<span> i;
</span><span>29</span>                 temp = ReSortMaxBranch(data, i, <span>2</span> * i + <span>1</span>, <span>2</span> * i + <span>2</span>, data.Count - <span>1</span><span>);
</span><span>30</span>                 <span>if</span> (temp !=<span> i)
</span><span>31</span> <span>                {
</span><span>32</span>                     <span>int</span> k =<span> i;
</span><span>33</span>                     <span>while</span> (k != temp &amp;&amp; temp &lt;= data.Count / <span>2</span> - <span>1</span><span>)
</span><span>34</span> <span>                    {
</span><span>35</span>                         k =<span> temp;
</span><span>36</span>                         temp = ReSortMaxBranch(data, temp, <span>2</span> * temp + <span>1</span>, <span>2</span> * temp + <span>2</span>, data.Count - <span>1</span><span>);
</span><span>37</span> <span>                    }
</span><span>38</span> <span>                }
</span><span>39</span> <span>            }
</span><span>40</span> <span>        }
</span><span>41</span> 
<span>42</span>         <span>public</span> <span>static</span> <span>int</span> ReSortMaxBranch(IList&lt;<span>int</span>&gt; data, <span>int</span> maxIndex, <span>int</span> left, <span>int</span> right, <span>int</span><span> lastIndex)
</span><span>43</span> <span>        {
</span><span>44</span>             <span>int</span><span> temp;
</span><span>45</span>             <span>if</span> (right &gt;<span> lastIndex)  <span>//父节点只有一个子节点
</span></span><span>46</span>                 temp =<span> left;
</span><span>47</span>             <span>else</span>
<span>48</span> <span>            {
</span><span>49</span>                 <span>if</span> (data[left] &gt;<span> data[right])
</span><span>50</span>                     temp =<span> left;
</span><span>51</span>                 <span>else</span> temp =<span> right;
</span><span>52</span> <span>            }
</span><span>53</span> 
<span>54</span>             <span>if</span> (data[maxIndex] &lt;<span> data[temp])
</span><span>55</span> <span>                Swap(data, maxIndex, temp);
</span><span>56</span>             <span>else</span> temp =<span> maxIndex;
</span><span>57</span>             <span>return</span><span> temp;
</span><span>58</span>         }

复制代码

过程解析：BuildMaxHeapify为排序前构建的最大堆数列方法，主要内容为从最后一个父节点开始往前将每个三角组合

（即父节点与它的两个子节点）符合父节点值最大的规则。ReSortMaxBranch为将三角调整为父节点值最大，

并返回该值之前的索引，用来判断是否进行了交换，以及原来的父节点值交换到了什么位置。在HeapSort里首先

构建了最大堆数列，然后将根节点交换到末尾，根节点不是最大值了，在while语句中对最大堆数列进行调整。

插曲：自从看了Martin Fowler大师《重构》第三版，我发现我更不喜欢写注释了。每次都想着尽量让方法的名字更贴切，

即使会造成方法的名字很长很丑。这算不算曲解了大师的意思啊！？上面的代码注释都是写博客的时候现加的（源代码很干净的。汗!）。

希尔排序

希尔排序是插入排序的一种更高效的改进版本。

在前面介绍的插入排序，我们知道1.它对有序数列排序的效率是非常高的 2.要排序的数向前移动是一步步进行的导致插入排序效率低。

希尔排序正是利用第一点，改善第二点，达到更理想的效果。

原理：通过奇妙的步长，插入排序间隔步长的元素，随后逐渐缩短步长至1，实现数列的插入排序。 维基入口

疑问：可以想象到排序间隔步长的数，会逐渐让数列变得有序，提升最后步长为1时标准插入排序的效率。在维基上看到这么

一句话“可能希尔排序最重要的地方在于当用较小步长排序后，以前用的较大步长仍然是有序的”注意用词是‘可能’。我的疑问是

这是个正确的命题吗？如何证明呢？看维基上也是由果推因，说是如果不是这样，就不会排序那么快了。可这我感觉还是太牵强了，

哪位大哥发现相关资料，希望能分享出来，不胜感激。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> ShellSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span><span> temp;
</span><span> 4</span>             <span>for</span> (<span>int</span> gap = data.Count / <span>2</span>; gap &gt; <span>0</span>; gap /= <span>2</span><span>)
</span><span> 5</span> <span>            {
</span><span> 6</span>                 <span>for</span> (<span>int</span> i = gap; i &lt; data.Count; i +=<span> gap)
</span><span> 7</span> <span>                {
</span><span> 8</span>                     temp =<span> data[i];
</span><span> 9</span>                     <span>for</span> (<span>int</span> j = i - gap; j &gt;= <span>0</span>; j -=<span> gap)
</span><span>10</span> <span>                    {
</span><span>11</span>                         <span>if</span> (data[j] &gt;<span> temp)
</span><span>12</span> <span>                        {
</span><span>13</span>                             data[j + gap] =<span> data[j];
</span><span>14</span>                             <span>if</span> (j == <span>0</span><span>)
</span><span>15</span> <span>                            {
</span><span>16</span>                                 data[j] =<span> temp;
</span><span>17</span>                                 <span>break</span><span>;
</span><span>18</span> <span>                            }
</span><span>19</span> <span>                        }
</span><span>20</span>                         <span>else</span>
<span>21</span> <span>                        {
</span><span>22</span>                             data[j + gap] =<span> temp;
</span><span>23</span>                             <span>break</span><span>;
</span><span>24</span> <span>                        }
</span><span>25</span> <span>                    }
</span><span>26</span> <span>                }
</span><span>27</span> <span>            }
</span><span>28</span>         }

复制代码

过程解析：采用的步长是N/2，每次取半，直至1。循环内部就是标准的插入排序。

——————

修正：修正后希尔排序才是真正牛叉的希尔啊！感谢@390218462的提出

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> ShellSortCorrect(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span><span> temp;
</span><span> 4</span>             <span>for</span> (<span>int</span> gap = data.Count / <span>2</span>; gap &gt; <span>0</span>; gap /= <span>2</span><span>)
</span><span> 5</span> <span>            {
</span><span> 6</span>                 <span>for</span> (<span>int</span> i = gap; i &lt; data.Count; <span>i++</span><span>)      // <span>i+ = gap 改为了 i++
</span></span><span> 7</span> <span>                {
</span><span> 8</span>                     temp =<span> data[i];
</span><span> 9</span>                     <span>for</span> (<span>int</span> j = i - gap; j &gt;= <span>0</span>; j -=<span> gap)
</span><span>10</span> <span>                    {
</span><span>11</span>                         <span>if</span> (data[j] &gt;<span> temp)
</span><span>12</span> <span>                        {
</span><span>13</span>                             data[j + gap] =<span> data[j];
</span><span>14</span>                             <span>if</span> (j == <span>0</span><span>)
</span><span>15</span> <span>                            {
</span><span>16</span>                                 data[j] =<span> temp;
</span><span>17</span>                                 <span>break</span><span>;
</span><span>18</span> <span>                            }
</span><span>19</span> <span>                        }
</span><span>20</span>                         <span>else</span>
<span>21</span> <span>                        {
</span><span>22</span>                             data[j + gap] =<span> temp;
</span><span>23</span>                             <span>break</span><span>;
</span><span>24</span> <span>                        }
</span><span>25</span> <span>                    }
</span><span>26</span> <span>                }
</span><span>27</span> <span>            }
</span><span>28</span>         }

复制代码

——————

这里实现的貌似是最差的希尔排序。主要源于步长的选择。维基上有各种牛叉的“凌波微步”，极限在哪里，

喜欢挑战的同学可以去学习学习。看维基排序算法里六种排序的测试，希尔最快，比快速排序还快！！我没实现啊！

只是对于神奇的步长更充满了敬畏。

基数排序

基数排序是一种非比较型整数排序。

“非比较型”是什么意思呢？因为它内部使用的是桶排序，而桶排序是非比较型排序。

这里就要说说桶排序了。一个非常有意思的排序。

桶排序

原理：取一定数量（数列中的最大值）的编好序号的桶，将数列每个数放进编号为它的桶里，然后将不是空的桶依次倒出来，

就组成有序数列了。  维基入口

好吧！聪明的人一眼就看出桶排序的破绽了。假设只有两个数1,10000，岂不是要一万个桶！？这确实是个问题啊！我也

没想出解决办法。我起初也以为桶排序就是一个通过牺牲空间来换取时间的排序算法，它不需要比较，所以是非比较型算法。

但看了有趣的演示的桶排序后，发现世界之大，你没有解决，不代表别人没解决，睿智的人总是很多。

1，9999的桶排序实现：new Int[2];总共有两个数，得出最大数9999的位数4，取10的4次幂即10000作为分母，

要排序的数（1或9999）作为分子，并乘以数列总数2，即1*2/10000,9999*2/10000得到各自的位置0,1，完成排序。

如果是1,10000进行排序的话，上面的做法就需要稍微加一些处理——发现最大数是10的n次幂，就将它作为分母，并

放在数列末尾就好了。

如果是9999,10000进行排序的话，那就需要二维数组了，两个都在位置1，位置0没数。这个时候就需要在放

入每个位置时采用其它排序（比如插入排序）办法对这个位置的多个数排序了。

为基数排序做个过渡，我这里实现了一个个位数桶排序

涉及到了当重复的数出现的处理。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<span> 1</span>         <span>public</span> <span>static</span> <span>void</span> BucketSortOnlyUnitDigit(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span>[] indexCounter = <span>new</span> <span>int</span>[<span>10</span><span>];
</span><span> 4</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; data.Count; i++<span>)
</span><span> 5</span> <span>            {
</span><span> 6</span>                 indexCounter[data[i]]++<span>;
</span><span> 7</span> <span>            }
</span><span> 8</span>             <span>int</span>[] indexBegin = <span>new</span> <span>int</span>[<span>10</span><span>];
</span><span> 9</span>             <span>for</span> (<span>int</span> i = <span>1</span>; i &lt; <span>10</span>; i++<span>)
</span><span>10</span> <span>            {
</span><span>11</span>                 indexBegin[i] = indexBegin[i-1]+<span> indexCounter[i-1];
</span><span>15</span> <span>            }
</span><span>16</span>             IList&lt;<span>int</span>&gt; tempList =<span> NewInstance(data, data.Count);
</span><span>17</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; data.Count; i++<span>)
</span><span>18</span> <span>            {
</span><span>19</span>                 <span>int</span> number =<span> data[i];
</span><span>20</span>                 tempList[indexBegin[number]++] =<span> data[i];
</span><span>21</span> <span>            }
</span><span>22</span>             data =<span> tempList;
</span><span>23</span>         }

复制代码

过程解析：indexCounter进行对每个数出现的频率的统计。indexBegin存储每个数的起始索引。

比如 1 1 2，indexCounter统计到0个0,2个1,1个2。indexBegin计算出0,1,2的起始索引分别为

0,0,2。当1个1已取出排序，那索引将+1,变为0,1,2。这样就通过提前给重复的数空出位置，解决了

重复的数出现的问题。当然，你也可以考虑用二维数组来解决重复。

下面继续基数排序。

基数排序原理：将整数按位数切割成不同的数字，然后按每个位数分别比较。

取得最大数的位数，从低位开始，每个位上进行桶排序。

实现如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<span> 1</span>         <span>public</span> <span>static</span> IList&lt;<span>int</span>&gt; RadixSort(IList&lt;<span>int</span>&gt;<span> data)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span> max = data[<span>0</span><span>];
</span><span> 4</span>             <span>for</span> (<span>int</span> i = <span>1</span>; i &lt; data.Count; i++<span>)
</span><span> 5</span> <span>            {
</span><span> 6</span>                 <span>if</span> (data[i] &gt;<span> max)
</span><span> 7</span>                     max =<span> data[i];
</span><span> 8</span> <span>            }
</span><span> 9</span>             <span>int</span> digit = <span>1</span><span>;
</span><span>10</span>             <span>while</span> (max / <span>10</span> != <span>0</span><span>)
</span><span>11</span> <span>            {
</span><span>12</span>                 digit++<span>;
</span><span>13</span>                 max /= <span>10</span><span>;
</span><span>14</span> <span>            }
</span><span>15</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; digit; i++<span>)
</span><span>16</span> <span>            {
</span><span>17</span>                 <span>int</span>[] indexCounter = <span>new</span> <span>int</span>[<span>10</span><span>];
</span><span>18</span>                 IList&lt;<span>int</span>&gt; tempList =<span> NewInstance(data, data.Count);
</span><span>19</span>                 <span>for</span> (<span>int</span> j = <span>0</span>; j &lt; data.Count; j++<span>)
</span><span>20</span> <span>                {
</span><span>21</span>                     <span>int</span> number = (data[j] % Convert.ToInt32(Math.Pow(<span>10</span>, i + <span>1</span>))) / Convert.ToInt32(Math.Pow(<span>10</span>, i));  <span>//</span><span>得出i+1位上的数</span>
<span>22</span>                     indexCounter[number]++<span>;
</span><span>23</span> <span>                }
</span><span>24</span>                 <span>int</span>[] indexBegin = <span>new</span> <span>int</span>[<span>10</span><span>];
</span><span>25</span>                 <span>for</span> (<span>int</span> k = <span>1</span>; k &lt; <span>10</span>; k++<span>)
</span><span>26</span> <span>                {
</span><span>27</span>                     indexBegin[k] = indexBegin[k - <span>1</span>] + indexCounter[k - <span>1</span><span>];
</span><span>28</span> <span>                }
</span><span>29</span>                 <span>for</span> (<span>int</span> k = <span>0</span>; k &lt; data.Count; k++<span>)
</span><span>30</span> <span>                {
</span><span>31</span>                     <span>int</span> number = (data[k] % Convert.ToInt32(Math.Pow(<span>10</span>, i + <span>1</span>))) / Convert.ToInt32(Math.Pow(<span>10</span><span>, i));
</span><span>32</span>                     tempList[indexBegin[number]++] =<span> data[k];
</span><span>33</span> <span>                }
</span><span>34</span>                 data =<span> tempList;
</span><span>35</span> <span>            }
</span><span>36</span>             <span>return</span><span> data;
</span><span>37</span>         }

复制代码

过程解析：得出最大数的位数，从低位开始桶排序。我写的这个实现代码并不简洁，但逻辑更清晰。

后面测试的时候我们就会发现，按理来说这个实现也还行吧！ 但并不如想象的那么快！

循环的次数太多？（统计频率n次+9次计算+n次放到新的数组）*位数。

创建的新实例太多？(new int[10]两次+NewInstance is反射判断创建实例+new int[n])*位数

测试比较

添加随机数组，数组有序校验，微软Linq排序

代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<span> 1</span>         <span>public</span> <span>static</span> <span>int</span>[] RandomSet(<span>int</span> length, <span>int</span><span> max)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span>[] result = <span>new</span> <span>int</span><span>[length];
</span><span> 4</span>             Random rand = <span>new</span><span> Random();
</span><span> 5</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; result.Length; i++<span>)
</span><span> 6</span> <span>            {
</span><span> 7</span>                 result[i] =<span> rand.Next(max);
</span><span> 8</span> <span>            }
</span><span> 9</span>             <span>return</span><span> result;
</span><span>10</span> <span>        }
</span><span>11</span> 
<span>12</span>         <span>public</span> <span>static</span> <span>bool</span> IsAscOrdered(IList&lt;<span>int</span>&gt;<span> data)
</span><span>13</span> <span>        {
</span><span>14</span>             <span>bool</span> flag = <span>true</span><span>;
</span><span>15</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; data.Count - <span>1</span>; i++<span>)
</span><span>16</span> <span>            {
</span><span>17</span>                 <span>if</span> (data[i] &gt; data[i + <span>1</span><span>])
</span><span>18</span>                     flag = <span>false</span><span>;
</span><span>19</span> <span>            }
</span><span>20</span>             <span>return</span><span> flag;
</span><span>21</span> <span>        }
</span><span>22</span> 
<span>23</span>         <span>public</span> <span>static</span> <span>void</span> TestMicrosoft(IList&lt;<span>int</span>&gt;<span> data)
</span><span>24</span> <span>        {
</span><span>25</span>             Stopwatch stopwatch = <span>new</span><span> Stopwatch();
</span><span>26</span> <span>            stopwatch.Start();
</span><span>27</span>             List&lt;<span>int</span>&gt; result = data.OrderBy(a =&gt;<span> a).ToList();
</span><span>28</span> <span>            stopwatch.Stop();
</span><span>29</span>             <span>string</span> methodName = <span>"</span><span>TestMicrosoft</span><span>"</span><span>;
</span><span>30</span>             <span>int</span> length =<span> methodName.Length;
</span><span>31</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; <span>40</span> - length; i++<span>)
</span><span>32</span> <span>            {
</span><span>33</span>                 methodName += <span>"</span> <span>"</span><span>;
</span><span>34</span> <span>            }
</span><span>35</span>             Console.WriteLine(methodName +
<span>36</span>                 <span>"</span><span>  IsAscOrdered:</span><span>"</span> + IsAscOrdered(result) + <span>"</span><span>  Time:</span><span>"</span> +<span> stopwatch.Elapsed.TotalSeconds);
</span><span>37</span> 
<span>38</span>         }

复制代码

测试主体如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<span> 1</span>         <span>static</span> <span>void</span> Main(<span>string</span><span>[] args)
</span><span> 2</span> <span>        {
</span><span> 3</span>             <span>int</span>[] aa = RandomSet(<span>50000</span>, <span>99999</span><span>);
</span><span> 4</span>             <span>//</span><span>int[] aa = OrderedSet(5000);</span>
<span> 5</span>             Console.WriteLine(<span>"</span><span>Array Length:</span><span>"</span> +<span> aa.Length);
</span><span> 6</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)SelectSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span> 7</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)BubbleSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span> 8</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)BubbleSortImprovedWithFlag, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span> 9</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)BubbleCocktailSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>10</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)InsertSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>11</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)InsertSortImprovedWithBinarySearch, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>12</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)QuickSortStrict, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>13</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)QuickSortRelax, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>14</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)QuickSortRelaxImproved, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>15</span>             RunTheMethod((Func&lt;IList&lt;<span>int</span>&gt;, IList&lt;<span>int</span>&gt;&gt;)MergeSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>16</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)ShellSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>17</span>             RunTheMethod((Func&lt;IList&lt;<span>int</span>&gt;, IList&lt;<span>int</span>&gt;&gt;)RadixSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>18</span>             RunTheMethod((Action&lt;IList&lt;<span>int</span>&gt;&gt;)HeapSort, aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>19</span>             TestMicrosoft(aa.Clone() <span>as</span> <span>int</span><span>[]);
</span><span>20</span> <span>            Console.Read();
</span><span>21</span> <span>        }
</span><span>22</span> 
<span>23</span>         <span>public</span> <span>static</span> <span>void</span> RunTheMethod(Func&lt;IList&lt;<span>int</span>&gt;, IList&lt;<span>int</span>&gt;&gt; method, IList&lt;<span>int</span>&gt;<span> data)
</span><span>24</span> <span>        {
</span><span>25</span>             Stopwatch stopwatch = <span>new</span><span> Stopwatch();
</span><span>26</span> <span>            stopwatch.Start();
</span><span>27</span>             IList&lt;<span>int</span>&gt; result =<span> method(data);
</span><span>28</span> <span>            stopwatch.Stop();
</span><span>29</span>             <span>string</span> methodName =<span> method.Method.Name;
</span><span>30</span>             <span>int</span> length =<span> methodName.Length;
</span><span>31</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; <span>40</span> - length; i++<span>)
</span><span>32</span> <span>            {
</span><span>33</span>                 methodName += <span>"</span> <span>"</span><span>;
</span><span>34</span> <span>            }
</span><span>35</span>             Console.WriteLine(methodName +
<span>36</span>                 <span>"</span><span>  IsAscOrdered:</span><span>"</span> + IsAscOrdered(result) + <span>"</span><span>  Time:</span><span>"</span> +<span> stopwatch.Elapsed.TotalSeconds);
</span><span>37</span> <span>        }
</span><span>38</span> 
<span>39</span>         <span>public</span> <span>static</span> <span>void</span> RunTheMethod(Action&lt;IList&lt;<span>int</span>&gt;&gt; method, IList&lt;<span>int</span>&gt;<span> data)
</span><span>40</span> <span>        {
</span><span>41</span>             Stopwatch stopwatch = <span>new</span><span> Stopwatch();
</span><span>42</span> <span>            stopwatch.Start();
</span><span>43</span> <span>            method(data);
</span><span>44</span> <span>            stopwatch.Stop();
</span><span>45</span>             <span>string</span> methodName =<span> method.Method.Name;
</span><span>46</span>             <span>int</span> length =<span> methodName.Length;
</span><span>47</span>             <span>for</span> (<span>int</span> i = <span>0</span>; i &lt; <span>40</span> - length; i++<span>)
</span><span>48</span> <span>            {
</span><span>49</span>                 methodName += <span>"</span> <span>"</span><span>;
</span><span>50</span> <span>            }
</span><span>51</span>             Console.WriteLine(methodName +
<span>52</span>                 <span>"</span><span>  IsAscOrdered:</span><span>"</span> + IsAscOrdered(data) + <span>"</span><span>  Time:</span><span>"</span> +<span> stopwatch.Elapsed.TotalSeconds);
</span><span>53</span>         }

复制代码

剩余代码折叠在此处

View Code

测试设备：win8(64位)，i7-3630QM,8G内存，vs2012

测试结果：

100000,50000,10000,5000,1000,100依次是：

结果分析：可以看出在大数组的时候，微软自带排序更接近快速排序。而当数组变小时，速度却没有明显提升，甚至变得更慢，

比如1000和100。可以推断出在数组足够小的时候，比较已经不是影响这个方法主要因素。而根据它对大数组的表现。我们可以

推断出它应该用的是快速排序。反编译验证下：

在System.Linq.EnumerableSorter下。有兴趣的同学可以去看下详细实现。

维基上也有个测试。硬件没我的好。时间是我测试结果时间的几百倍。有兴趣的同学可以比较下。

在上面的测试中，我们可以看到快速最快，归并其次，冒泡最慢（维基上是希尔最快，估计使用的是某种神奇的步长）。

在我这里，以前实现的希尔还不如二分查找优化版的快，修正后希尔快了相当多，上面测试的希尔排序是以前错误的实现。

修正后的实现测试效果请点击右侧导航到希尔排序查看。希尔排序是一种神奇又有潜力的算法。步长不好会很挫！

而基数排序却是比平均时间复杂度为o(nlogn)的堆排序，归并排序，快速排序还要慢的，虽然它的平均时间复杂度为o(n)。

冒泡标识优化版对随机数列结果优化不明显，鸡尾酒版优化可以看到，但也不是很厉害。

插入排序二分查找优化版优化比较明显。我优化的快速排序QuickSortRelaxImproved优化也不明显。

以上是随机数列的测试结果，最大值为99999。

而对于有序数列，这些方法表现又会如何呢？

我这里就不演示了。本文末尾会附上demo，大家可以自行测试。

有意思的是:

我在测试有序数列的时候，QuickSortStrict方法栈溢出了（stack overflow exception）。这个异常

是让我去stackoverflow搜寻答案吗？哈哈！我确信我的方法不是无限循环。跳过一堆链接。。。我是

在测试10000个数排序的时候发生的错误。我跟踪后发现大约在9400多次递归的时候，栈溢出。找啊找

终于找见了一个类似的问题。上面说如果一个递归9000多次而没有返回值，也会报栈溢出的。而这个方法

对于10000个有序数列，确实每次减少一个数地递归，次数会超过限制。

我的算法理论不怎么好，对于时间复杂度和空间复杂度，还有稳定度，搞得也不怎么清楚，只知道个大致的

意思。各位要笔试面试的朋友可以去维基百科这个表来了解学习。

总结

我觉得使用IList更贴近数列，更能展现基本的操作。所以我的实现中都没有将它强制转化为List

或者int[]来调用微软封装的方法。这样说来，题目说C#实现倒快有点名不副实了。不过这样却也方便了其它语言

朋友。比如将我这篇博文里的实现随便改改，就可以说是另一个语言版本的8种排序算法了。哈哈！在这里，

我想说下这次学习排序对我的意义：老久不怎么动脑了，突然动起来，磨磨唧唧地得出结果，最后倒也有点成就感！

在学习过程中，经常会脑子转不过弯，想不通的，只是走在路上或者睡觉前突然灵感一现，有点小惊喜的感觉！

这大概就是进步的特征吧！哈哈！这次写demo+写博客花费了不少时间，倒也收获颇多，尤其在我将8种

排序都实现之前，没进行过一次测试，全部实现完成后，测试时各种索引越界+无限循环+各种问题，没几个

能跑通的，到后来的几乎都没有问题，也算是锻炼了思维，找出错原因的能力。本篇是自我学习的一个总结，

要学习及锻炼的园友，还望一定自己实现一下，可以和我的比较一下，解除疑惑或者提出改进。

主要参考：维基百科，有趣的演示

Demo源码

PS:我打算三月份去广州发展，主要会Asp.net mvc+jquery（不介意学习新的技术[除了webform]及语言[除了java]）。

发表于 更新于

设计模式是软件开发中经过总结和验证的、解决特定场景下常见问题的最佳实践，它能提升代码的可复用性、可维护性、可读性和扩展性。根据目的和应用场景，设计模式主要分为创建型模式、结构型模式、行为型模式三大类，以下是各类模式的核心总结及对应UML图：

一、创建型模式

创建型模式聚焦于对象的创建过程，封装对象创建的细节，降低创建逻辑与业务逻辑的耦合，让程序在创建对象时更灵活。

1. 单例模式（Singleton）

  • 核心意图：保证一个类仅有一个实例，并提供一个全局访问点。

  • 适用场景：配置管理、日志记录器、数据库连接池等需唯一实例的场景。

  • 实现要点：私有化构造方法，通过静态方法/属性返回唯一实例；需考虑线程安全（如懒汉式加锁、饿汉式提前初始化）、序列化/反序列化破坏单例的问题。

  • 优缺点：优点是节省资源、全局统一访问；缺点是违背单一职责，扩展困难，可能引发并发问题（未妥善处理时）。

UML类图：

2. 工厂方法模式（Factory Method）

  • 核心意图：定义创建对象的接口，让子类决定实例化哪个类，将对象创建延迟到子类。

  • 适用场景：产品种类可扩展，创建逻辑需隔离的场景（如日志框架支持不同日志输出类型）。

  • 实现要点：抽象工厂类定义创建方法，具体工厂类实现该方法创建对应产品。

  • 优缺点：优点是符合开闭原则，解耦产品创建与使用；缺点是新增产品需新增工厂类，类数量增多。

UML类图：

3. 抽象工厂模式（Abstract Factory）

  • 核心意图：提供一个创建一系列相关或相互依赖对象的接口，无需指定具体类。

  • 适用场景：需创建一套“产品族”（如操作系统+UI组件组合、数据库+驱动组合）的场景。

  • 实现要点：抽象工厂定义多个产品创建方法，具体工厂实现所有方法，产出对应产品族。

  • 优缺点：优点是保证产品族一致性，隔离具体产品；缺点是新增产品族需修改抽象工厂，违背开闭原则。

UML类图：

4. 建造者模式（Builder）

  • 核心意图：将复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

  • 适用场景：对象属性多、构造逻辑复杂（如建造汽车、生成复杂文档）。

  • 实现要点：建造者类封装构建步骤，指挥者类控制构建流程，产品类表示最终对象。

  • 优缺点：优点是解耦构建与表示，灵活控制构建过程；缺点是产品属性固定时冗余，类数量增加。

UML类图：

5. 原型模式（Prototype）

  • 核心意图：通过复制现有实例（原型）创建新对象，避免重复初始化开销。

  • 适用场景：对象创建成本高（如数据库查询后的数据对象）、需批量创建相似对象的场景。

  • 实现要点：实现克隆接口（浅克隆/深克隆），通过原型对象复制生成新对象。

  • 优缺点：优点是简化创建过程，提升性能；缺点是深克隆需处理复杂引用关系。

UML类图：

二、结构型模式

结构型模式关注类和对象的组合方式，通过合理的结构设计，提升代码的灵活性和复用性，解决类/对象间的耦合与扩展问题。

1. 适配器模式（Adapter）

  • 核心意图：将一个类的接口转换成客户希望的另一个接口，让不兼容的类可以协同工作。

  • 适用场景：集成第三方库、复用现有类但接口不匹配、新旧系统对接。

  • 实现要点：类适配器（继承适配者）、对象适配器（组合适配者）、接口适配器（默认空实现）。

  • 优缺点：优点是复用现有代码，解耦接口与实现；缺点是增加额外类，复杂场景可能导致适配链过长。

UML类图（对象适配器）：

2. 装饰器模式（Decorator）

  • 核心意图：动态地给一个对象添加一些额外的职责，比继承更灵活。

  • 适用场景：需扩展对象功能，且功能可组合（如IO流、日志增强、权限叠加）。

  • 实现要点：装饰器类与被装饰类实现同一接口，持有被装饰对象引用，重写方法并增强逻辑。

  • 优缺点：优点是灵活扩展，符合开闭原则；缺点是多层装饰会增加代码复杂度。

UML类图：

3. 代理模式（Proxy）

  • 核心意图：为其他对象提供一种代理以控制对这个对象的访问。

  • 适用场景：远程代理（RPC）、虚拟代理（懒加载）、保护代理（权限控制）、日志代理（监控）。

  • 实现要点：静态代理（手动编写代理类）、动态代理（JDK动态代理、CGLIB），代理类与目标类实现同一接口/继承目标类。

  • 优缺点：优点是隔离目标对象，增强访问控制；缺点是增加代理层，可能降低性能。

UML类图（静态代理）：

4. 外观模式（Facade）

  • 核心意图：为子系统中的一组接口提供一个一致的入口，简化子系统的使用。

  • 适用场景：复杂系统（如电商下单：库存、支付、物流子系统）、对外提供统一API。

  • 实现要点：外观类封装子系统交互逻辑，对外暴露简单接口。

  • 优缺点：优点是降低使用复杂度，解耦客户端与子系统；缺点是外观类可能成为“上帝类”，耦合过多逻辑。

UML类图：

5. 桥接模式（Bridge）

  • 核心意图：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

  • 适用场景：多维度变化的场景（如“形状+颜色”、“操作系统+文件系统”）。

  • 实现要点：抽象类持有实现类引用，抽象与实现分层，各自独立扩展。

  • 优缺点：优点是解耦抽象与实现，符合开闭原则；缺点是增加代码复杂度，理解成本高。

UML类图：

6. 组合模式（Composite）

  • 核心意图：将对象组合成树形结构以表示“部分-整体”的层次结构，统一对待单个对象和组合对象。

  • 适用场景：树形结构场景（如菜单、文件目录、组织架构）。

  • 实现要点：抽象组件类定义公共方法，叶子节点类表示单个对象，组合节点类包含子组件集合。

  • 优缺点：优点是统一访问单个/组合对象，简化客户端逻辑；缺点是设计复杂，限制类型时需额外判断。

UML类图：

7. 享元模式（Flyweight）

  • 核心意图：运用共享技术有效地支持大量细粒度的对象，减少内存占用。

  • 适用场景：大量相似对象（如池化资源、字符常量池、游戏角色）。

  • 实现要点：区分内部状态（共享）和外部状态（不共享），享元工厂管理共享对象池。

  • 优缺点：优点是减少内存消耗，提升性能；缺点是增加系统复杂度，需处理外部状态。

UML类图：

三、行为型模式

行为型模式关注对象间的交互和职责分配，优化对象的通信方式和行为逻辑，提升代码的协作性和可扩展性。

1. 观察者模式（Observer）

  • 核心意图：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖它的对象都得到通知并自动更新。

  • 适用场景：事件驱动、发布-订阅（如GUI事件、消息通知、数据监听）。

  • 实现要点：主题（被观察者）维护观察者列表，提供注册/移除/通知方法；观察者实现更新方法。

  • 优缺点：优点是解耦主题与观察者，支持广播通知；缺点是观察者过多时通知效率低，可能引发循环依赖。

UML类图：

2. 策略模式（Strategy）

  • 核心意图：定义一系列算法，将每个算法封装起来，使它们可以互相替换，且算法的变化不影响使用算法的客户。

  • 适用场景：多种算法可选（如排序算法、支付方式、优惠计算）。

  • 实现要点：策略接口定义算法方法，具体策略类实现算法，上下文类持有策略引用并调用。

  • 优缺点：优点是算法可灵活切换，符合开闭原则；缺点是客户端需了解所有策略，策略过多时类数量增加。

UML类图：

3. 模板方法模式（Template Method）

  • 核心意图：定义一个操作中的算法骨架，将一些步骤延迟到子类中，子类不改变算法结构即可重定义某些步骤。

  • 适用场景：流程固定但步骤实现可变（如框架初始化、报表生成、测试流程）。

  • 实现要点：抽象父类定义模板方法（固定流程）和抽象方法（可变步骤），子类实现抽象方法。

  • 优缺点：优点是复用流程代码，控制扩展点；缺点是模板方法过多时父类复杂，子类受限。

UML类图：

4. 迭代器模式（Iterator）

  • 核心意图：提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示。

  • 适用场景：遍历集合（如列表、集合、树），统一遍历接口。

  • 实现要点：迭代器接口定义遍历方法（next、hasNext），聚合类提供获取迭代器的方法。

  • 优缺点：优点是统一遍历接口，解耦聚合与遍历；缺点是简单遍历场景下增加冗余类。

UML类图：

5. 命令模式（Command）

  • 核心意图：将请求封装成对象，以便使用不同的请求、队列或日志来参数化其他对象，支持撤销/重做操作。

  • 适用场景：请求解耦（如GUI按钮、事务操作、任务队列）。

  • 实现要点：命令接口定义执行方法，具体命令类封装接收者和动作，调用者触发命令执行。

  • 优缺点：优点是解耦请求者与接收者，支持命令组合、撤销；缺点是类数量增加，简单场景冗余。

UML类图：

6. 责任链模式（Chain of Responsibility）

  • 核心意图：为请求创建一个接收者对象的链，使多个对象都有机会处理请求，避免请求发送者与接收者耦合。

  • 适用场景：请求需多节点处理（如权限审批、日志分级、异常处理链）。

  • 实现要点：处理者接口定义处理方法，每个处理者持有下一个处理者引用，自行处理或转发请求。

  • 优缺点：优点是解耦请求与处理，动态调整责任链；缺点是请求可能无人处理，调试复杂。

UML类图：

7. 状态模式（State）

  • 核心意图：允许对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。

  • 适用场景：对象行为依赖状态（如订单状态、电梯状态、游戏角色状态）。

  • 实现要点：状态接口定义行为方法，具体状态类实现对应行为，上下文类持有当前状态并委托状态处理。

  • 优缺点：优点是状态逻辑集中管理，避免大量if-else；缺点是状态多时有大量状态类。

UML类图：

8. 备忘录模式（Memento）

  • 核心意图：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便后续恢复。

  • 适用场景：撤销操作（如编辑器、游戏存档、事务回滚）。

  • 实现要点：备忘录类存储状态，原发器创建/恢复备忘录，管理者管理备忘录。

  • 优缺点：优点是支持状态回滚，封装状态；缺点是消耗内存（大量备忘录）。

UML类图：

9. 中介者模式（Mediator）

  • 核心意图：用一个中介对象来封装一系列的对象交互，使各对象不需要显式地相互引用，降低耦合。

  • 适用场景：多对象复杂交互（如聊天室、GUI组件交互、分布式系统协调）。

  • 实现要点：中介者接口定义交互方法，具体中介者封装对象间交互，同事类通过中介者通信。

  • 优缺点：优点是解耦对象间交互，简化维护；缺点是中介者可能成为“上帝类”，复杂度高。

UML类图：

10. 解释器模式（Interpreter）

  • 核心意图：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

  • 适用场景：简单语法解析（如表达式计算、配置解析、自定义脚本）。

  • 实现要点：抽象表达式定义解释方法，终结符/非终结符表达式实现具体逻辑，环境类存储上下文。

  • 优缺点：优点是灵活扩展语法；缺点是语法复杂时类数量爆炸，效率低。

UML类图：

四、设计模式核心原则

所有设计模式均围绕SOLID原则展开，是设计模式的底层逻辑：

  1. 单一职责原则（SRP）：一个类只负责一个职责，降低耦合。

  2. 开闭原则（OCP）：对扩展开放，对修改关闭，通过抽象/接口实现。

  3. 里氏替换原则（LSP）：子类可替换父类且不影响程序正确性。

  4. 接口隔离原则（ISP）：拆分臃肿接口，提供最小化专用接口。

  5. 依赖倒置原则（DIP）：依赖抽象而非具体实现，降低耦合。

五、设计模式使用建议

  1. 不要过度设计：仅在问题重复出现、需复用/扩展时使用，避免为了用模式而用模式。

  2. 优先复用现有框架：多数框架已内置设计模式（如Spring的单例、代理，MyBatis的工厂、装饰器），无需重复实现。

  3. 结合场景选择：如创建对象选创建型，扩展功能选装饰器/策略，解耦交互选观察者/中介者。

  4. 理解本质而非形式：模式的核心是解决问题的思路，而非固定代码结构。

设计模式是经验的沉淀，掌握其思想能让代码更贴合“高内聚、低耦合”的软件设计目标，提升系统的可维护性和扩展性。

发表于 更新于 分类于 ，

解释器模式（Interpreter Pattern）是行为型设计模式的重要分支，其核心设计思想是定义特定语言的文法规则，并构建对应的解释器，将复杂的语法解析拆解为多个简单的解释器节点，通过组合这些节点完成整体语法的解释与执行。该模式专注于“语法解析与逻辑执行”的解耦，适用于处理固定语法规则的场景，如表达式计算、自定义配置解析、简单脚本解释、领域特定语言（DSL）实现等。本文将从核心结构拆解、多语言落地实现、优缺点深度剖析、适用场景梳理及实战总结等维度，系统解读解释器模式的设计思想与工程实践，为开发者提供可直接复用的技术方案。

一、解释器模式核心结构

解释器模式的核心价值在于“拆分复杂语法、实现模块化解析”，通过五大核心角色的协同工作，完成语法树的构建与解释执行，各角色职责边界清晰、耦合度低，具体定义与交互逻辑如下：

1.1 抽象表达式（Abstract Expression）

抽象表达式是所有具体表达式的基类或接口，核心职责是定义统一的解释操作接口（通常命名为Interpret方法）。该接口是所有表达式节点的通用入口，确保终结符与非终结符表达式能以统一的方式被调用，为多态解析提供基础。

1.2 终结符表达式（Terminal Expression）

终结符表达式是语法树的叶子节点，对应文法中的终结符（即语法规则中不可再拆分的最小单元），如算术表达式中的数字、常量，配置语法中的键值对等。其核心职责是实现终结符的具体解释逻辑，无需依赖其他表达式，直接返回解析结果。

1.3 非终结符表达式（Nonterminal Expression）

非终结符表达式对应文法中的非终结符（可拆分为多个子表达式的语法单元），如算术表达式中的加减乘除运算符、逻辑表达式中的与或非逻辑等。其核心职责是组合多个子表达式（终结符或非终结符），通过递归调用子表达式的解释方法，完成复杂语法的解析与执行。

1.4 环境（Context）

环境类用于存储解释器的全局上下文信息，供所有表达式共享使用，如变量映射关系、语法解析的中间状态、计算结果缓存等。环境类的存在的可以减少表达式之间的直接依赖，同时为后续扩展（如变量替换）提供灵活支撑。

1.5 客户端（Client）

客户端负责两个核心操作：一是根据预设的文法规则，构建由终结符表达式和非终结符表达式组成的语法树；二是调用语法树根节点的解释方法，触发整个语法树的逐层解析与执行，最终获取解析结果。

核心交互流程：客户端定义文法规则 → 构建语法树（组合终结符与非终结符表达式） → 初始化环境上下文 → 调用根节点Interpret方法 → 子表达式逐层递归解析 → 返回最终执行结果。

二、多语言实现解释器模式

以“简单算术表达式解析（支持整数加减运算）”为统一实战场景，设计核心逻辑：通过解释器模式解析表达式“1 + 2 - 3”，拆解为“加法表达式”与“减法表达式”的组合，最终计算出结果。以下提供C#、Python、Golang、C++及纯C的可运行实现，贴合各语言原生特性，补充规范注释、边界校验与资源释放逻辑，兼顾实用性与严谨性，清晰呈现模式在不同语言中的适配思路。

2.1 C# 实现（面向对象规范实现）

C#作为强类型面向对象语言，通过接口定义抽象表达式，依托类实现终结符与非终结符逻辑，借助多态特性实现统一解析。代码结构清晰、可维护性高，适用于企业级应用中的简单表达式解析、配置语法解析等场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
using System;

/// <summary>
/// 环境类：存储解释器全局上下文（此处简化为无状态，可扩展添加变量映射等）
/// </summary>
public class Context { }

/// <summary>
/// 抽象表达式接口：定义统一的解释操作
/// </summary>
public interface IExpression
{
    /// <summary>
    /// 解释方法：执行当前表达式的解析逻辑
    /// </summary>
    /// <param name="context">全局上下文</param>
    /// <returns>解析执行结果</returns>
    int Interpret(Context context);
}

/// <summary>
/// 终结符表达式：数字表达式，解析算术表达式中的数字
/// </summary>
public class NumberExpression : IExpression
{
    /// <summary>
    /// 存储的数字值
    /// </summary>
    private readonly int _number;

    /// <summary>
    /// 构造函数：初始化数字表达式
    /// </summary>
    /// <param name="number">数字值</param>
    public NumberExpression(int number)
    {
        _number = number;
    }

    /// <summary>
    /// 解释逻辑：直接返回数字本身
    /// </summary>
    public int Interpret(Context context)
    {
        return _number;
    }
}

/// <summary>
/// 非终结符表达式：加法表达式，解析“+”运算
/// </summary>
public class AddExpression : IExpression
{
    /// <summary>
    /// 左表达式（加法左侧的子表达式）
    /// </summary>
    private readonly IExpression _leftExpression;

    /// <summary>
    /// 右表达式（加法右侧的子表达式）
    /// </summary>
    private readonly IExpression _rightExpression;

    /// <summary>
    /// 构造函数：组合两个子表达式
    /// </summary>
    /// <param name="left">左子表达式</param>
    /// <param name="right">右子表达式</param>
    public AddExpression(IExpression left, IExpression right)
    {
        _leftExpression = left ?? throw new ArgumentNullException(nameof(left), "左表达式不可为null");
        _rightExpression = right ?? throw new ArgumentNullException(nameof(right), "右表达式不可为null");
    }

    /// <summary>
    /// 解释逻辑：递归解析左右子表达式，返回加法结果
    /// </summary>
    public int Interpret(Context context)
    {
        return _leftExpression.Interpret(context) + _rightExpression.Interpret(context);
    }
}

/// <summary>
/// 非终结符表达式：减法表达式，解析“-”运算
/// </summary>
public class SubtractExpression : IExpression
{
    /// <summary>
    /// 左表达式（减法左侧的子表达式）
    /// </summary>
    private readonly IExpression _leftExpression;

    /// <summary>
    /// 右表达式（减法右侧的子表达式）
    /// </summary>
    private readonly IExpression _rightExpression;

    /// <summary>
    /// 构造函数：组合两个子表达式
    /// </summary>
    /// <param name="left">左子表达式</param>
    /// <param name="right">右子表达式</param>
    public SubtractExpression(IExpression left, IExpression right)
    {
        _leftExpression = left ?? throw new ArgumentNullException(nameof(left), "左表达式不可为null");
        _rightExpression = right ?? throw new ArgumentNullException(nameof(right), "右表达式不可为null");
    }

    /// <summary>
    /// 解释逻辑：递归解析左右子表达式，返回减法结果
    /// </summary>
    public int Interpret(Context context)
    {
        return _leftExpression.Interpret(context) - _rightExpression.Interpret(context);
    }
}

// 客户端：构建语法树并执行解析
class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 1. 初始化上下文
            Context context = new Context();

            // 2. 构建语法树：解析表达式 “1 + 2 - 3”
            // 结构：减法表达式（左：加法表达式，右：数字表达式3）
            // 加法表达式（左：数字表达式1，右：数字表达式2）
            IExpression expression = new SubtractExpression(
                new AddExpression(
                    new NumberExpression(1),
                    new NumberExpression(2)
                ),
                new NumberExpression(3)
            );

            // 3. 执行解析并输出结果
            int result = expression.Interpret(context);
            Console.WriteLine($"C# 解析表达式「1 + 2 - 3」，执行结果：{result}"); // 输出 0
        }
        catch (Exception ex)
        {
            Console.WriteLine($"解析异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（动态语言简洁实现）

Python遵循“鸭子类型”，无需显式定义接口，通过基类+子类继承实现抽象表达式逻辑，语法简洁、无冗余类型声明。依托动态特性，可灵活扩展表达式类型，无需修改核心解析逻辑，适用于快速开发、轻量级解析场景（如简单配置解析、小型计算器）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
class Context:
    """环境类：存储解释器全局上下文，可扩展添加变量映射等功能"""
    pass

class Expression:
    """抽象表达式基类：定义统一的解释接口"""
    def interpret(self, context):
        """
        解释方法：子类必须实现该方法，执行具体解析逻辑
        :param context: 全局上下文对象
        :return: 解析执行结果
        """
        raise NotImplementedError("子类必须实现interpret方法，完成具体解析逻辑")

class NumberExpression(Expression):
    """终结符表达式：数字表达式，解析算术表达式中的数字"""
    def __init__(self, number):
        """
        初始化数字表达式
        :param number: 数字值（整数）
        """
        if not isinstance(number, int):
            raise TypeError("数字表达式仅支持整数类型")
        self.number = number

    def interpret(self, context):
        """解释逻辑：直接返回数字本身"""
        return self.number

class AddExpression(Expression):
    """非终结符表达式：加法表达式，解析“+”运算"""
    def __init__(self, left, right):
        """
        初始化加法表达式，组合两个子表达式
        :param left: 左子表达式（Expression子类实例）
        :param right: 右子表达式（Expression子类实例）
        """
        if not isinstance(left, Expression) or not isinstance(right, Expression):
            raise TypeError("加法表达式的左右子表达式必须是Expression子类实例")
        self.left = left
        self.right = right

    def interpret(self, context):
        """解释逻辑：递归解析左右子表达式，返回加法结果"""
        return self.left.interpret(context) + self.right.interpret(context)

class SubtractExpression(Expression):
    """非终结符表达式：减法表达式，解析“-”运算"""
    def __init__(self, left, right):
        """
        初始化减法表达式，组合两个子表达式
        :param left: 左子表达式（Expression子类实例）
        :param right: 右子表达式（Expression子类实例）
        """
        if not isinstance(left, Expression) or not isinstance(right, Expression):
            raise TypeError("减法表达式的左右子表达式必须是Expression子类实例")
        self.left = left
        self.right = right

    def interpret(self, context):
        """解释逻辑：递归解析左右子表达式，返回减法结果"""
        return self.left.interpret(context) - self.right.interpret(context)

# 客户端：构建语法树并执行解析
if __name__ == "__main__":
    try:
        # 1. 初始化上下文
        context = Context()

        # 2. 构建语法树：解析表达式 “1 + 2 - 3”
        expression = SubtractExpression(
            AddExpression(
                NumberExpression(1),
                NumberExpression(2)
            ),
            NumberExpression(3)
        )

        # 3. 执行解析并输出结果
        result = expression.interpret(context)
        print(f"Python 解析表达式「1 + 2 - 3」，执行结果：{result}")  # 输出 0
    except Exception as e:
        print(f"解析异常：{str(e)}")

2.3 Golang 实现（接口至上轻量实现）

Go语言无类和继承，遵循“组合优于继承”原则，通过接口定义抽象表达式，结构体实现接口方法，依托接口多态实现统一解析。代码极简高效、无冗余，贴合Go语言“简洁、高效”的设计理念，适配高并发后端场景（如服务端配置解析、简单规则引擎）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package main

import (
 "fmt"
)

// Context 环境类：存储解释器全局上下文（可扩展变量映射等）
type Context struct{}

// Expression 抽象表达式接口：定义统一的解释方法
type Expression interface {
  nterpret(context *Context) int
}

// NumberExpression 终结符表达式：数字表达式
type NumberExpression struct {
        num // 存储的数字值
}

// NewNumberExpression 初始化数字表达式，添加参数校验
func NewNumberExpression(number int) *NumberExpression {
        reumberExpression{number: number}
}

// Interpret 解释方法：直接返回数字本身
func (n *NumberExpression) Interpret(context *Context) int {
        retumber
}

// AddExpression 非终结符表达式：加法表达式
type AddExpression struct {
    t  Expression // 左子表达式
        rpression // 右子表达式
}

// NewAddExpression 初始化加法表达式，组合两个子表达式并校验
func NewAddExpression(left, right Expression) (*AddExpression, error) {
    left == nil || right == nil {
   eturn nil, fmt.Errorf("加法表达式的左右子表达式不可为nil")
    return &AddExpression{left: left, right: right}, nil
}

// Interpret 解释方法：递归解析左右子表达式，返回加法结果
func (a *AddExpression) Interpret(context *Context) int {
        r.left.Interpret(context) + a.right.Interpret(context)
}

// SubtractExpression 非终结符表达式：减法表达式
type SubtractExpression struct {
       Expression // 左子表达式
        right Expression // 右子表达式
}

// NewSubtractExpression 初始化减法表达式，组合两个子表达式并校验
func NewSubtractExpression(left, right Expression) (*SubtractExpression, error) {
        if left == nil || right == nil {
                return nil, fmt.Errorf("减法表达式的左右子表达式不可为nil")
        }
        return &SubtractExpression{left: left, right: right}, nil
}

// Interpret 解释方法：递归解析左右子表达式，返回减法结果
func (s *SubtractExpression) Interpret(context *Context) int {
        return s.left.Interpret(context) - s.right.Interpret(context)
}

// 客户端：构建语法树并执行解析
func main() {
        // 1. 初始化上下文
        context := &Context{}

        // 2. 构建语法树：解析表达式 “1 + 2 - 3”
        // 先创建加法表达式
        addExpr, err := NewAddExpression(NewNumberExpression(1), NewNumberExpression(2))
        if err != nil {
                fmt.Printf("创建加法表达式失败：%v\n", err)
                return
        }
        // 再创建减法表达式（组合加法表达式与数字表达式）
        subExpr, err := NewSubtractExpression(addExpr, NewNumberExpression(3))
        if err != nil {
                fmt.Printf("创建减法表达式失败：%v\n", err)
                return
        }

        // 3. 执行解析并输出结果
        result := subExpr.Interpret(context)
        fmt.Printf("Golang 解析表达式「1 + 2 - 3」，执行结果：%d\n", result) // 输出 0
}
        left eturn a    }
                     r    if ight Ex    lefurn n.nturn &Nber int      I

2.4 C++ 实现（抽象类+虚函数经典实现）

C++通过抽象类（纯虚函数）定义抽象表达式，子类继承并实现具体解释逻辑，依托虚函数实现多态解析。同时通过手动内存管理，避免内存泄漏，兼顾灵活性与高性能，适用于底层开发、高频调用场景（如编译器简化版表达式解析、嵌入式设备规则解析）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#include <iostream>
#include <stdexcept>
using namespace std;

/// <summary>
/// 环境类：存储解释器全局上下文（可扩展变量映射等）
/// </summary>
class Context {};

/// <summary>
/// 抽象表达式（抽象类）：定义统一的解释接口（纯虚函数）
/// </summary>
class Expression {
public:
    /// <summary>
    /// 纯虚函数：解释方法，子类必须实现
    /// </summary>
    virtual int interpret(Context* context) = 0;
    
    /// <summary>
    /// 虚析构函数：确保子类对象正确释放
    /// </summary>
    virtual ~Expression() = default;
};

/// <summary>
/// 终结符表达式：数字表达式
/// </summary>
class NumberExpression : public Expression {
private:
    int number; // 存储的数字值
public:
    /// <summary>
    /// 构造函数：初始化数字表达式
    /// </summary>
    NumberExpression(int num) : number(num) {}

    /// <summary>
    /// 解释方法：直接返回数字本身
    /// </summary>
    int interpret(Context* context) override {
        return number;
    }
};

/// <summary>
/// 非终结符表达式：加法表达式
/// </summary>
class AddExpression : public Expression {
private:
    Expression* left;  // 左子表达式
    Expression* right; // 右子表达式
public:
    /// <summary>
    /// 构造函数：组合两个子表达式，添加参数校验
    /// </summary>
    AddExpression(Expression* l, Expression* r) {
        if (l == nullptr || r == nullptr) {
            throw invalid_argument("加法表达式的左右子表达式不可为nullptr");
        }
        left = l;
        right = r;
    }

    /// <summary>
    /// 解释方法：递归解析左右子表达式，返回加法结果
    /// </summary>
    int interpret(Context* context) override {
        return left->interpret(context) + right->interpret(context);
    }

    /// <summary>
    /// 析构函数：释放子表达式内存，避免泄漏
    /// </summary>
    ~AddExpression() override {
        delete left;
        delete right;
    }
};

/// <summary>
/// 非终结符表达式：减法表达式
/// </summary>
class SubtractExpression : public Expression {
private:
    Expression* left;  // 左子表达式
    Expression* right; // 右子表达式
public:
    /// <summary>
    /// 构造函数：组合两个子表达式，添加参数校验
    /// </summary>
    SubtractExpression(Expression* l, Expression* r) {
        if (l == nullptr || r == nullptr) {
            throw invalid_argument("减法表达式的左右子表达式不可为nullptr");
        }
        left = l;
        right = r;
    }

    /// <summary>
    /// 解释方法：递归解析左右子表达式，返回减法结果
    /// </summary>
    int interpret(Context* context) override {
        return left->interpret(context) - right->interpret(context);
    }

    /// <summary>
    /// 析构函数：释放子表达式内存，避免泄漏
    /// </summary>
    ~SubtractExpression() override {
        delete left;
        delete right;
    }
};

// 客户端：构建语法树并执行解析
int main() {
    try {
        // 1. 初始化上下文
        Context* context = new Context();

        // 2. 构建语法树：解析表达式 “1 + 2 - 3”
        Expression* expression = new SubtractExpression(
            new AddExpression(
                new NumberExpression(1),
                new NumberExpression(2)
            ),
            new NumberExpression(3)
        );

        // 3. 执行解析并输出结果
        int result = expression->interpret(context);
        cout << "C++ 解析表达式「1 + 2 - 3」，执行结果：" << result << endl; // 输出 0

        // 4. 释放内存，避免泄漏
        delete expression;
        delete context;
    } catch (const exception& e) {
        cout << "解析异常：" << e.what() << endl;
        return -1;
    }
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C无面向对象特性，通过“结构体封装数据+函数指针封装行为”模拟解释器模式的核心逻辑，依托函数指针实现统一的解释接口，通过命名约定区分终结符与非终结符表达式。底层可控性强、无额外依赖，适用于嵌入式、底层开发等资源受限场景，完整还原模式“拆分语法、组合解析”的核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 前向声明：解决结构体与函数指针的交叉引用
typedef struct Context Context;
typedef struct Expression Expression;

/// <summary>
/// 环境类（结构体）：存储解释器全局上下文
/// </summary>
typedef struct Context {
    // 可扩展添加变量映射、中间结果缓存等
} Context;

/// <summary>
/// 解释函数指针：模拟抽象表达式的Interpret方法
/// </summary>
typedef int (*InterpretFunc)(Expression*, Context*);

/// <summary>
/// 表达式结构体（模拟抽象表达式）
/// </summary>
typedef struct Expression {
    InterpretFunc interpret; // 函数指针：解释方法
    void* data;              // 存储具体数据（数字/子表达式）
} Expression;

/// <summary>
/// 终结符：数字表达式的数据结构
/// </summary>
typedef struct {
    int number; // 存储的数字值
} NumberData;

/// <summary>
/// 非终结符：加减表达式的数据结构（二元表达式通用）
/// </summary>
typedef struct {
    Expression* left;  // 左子表达式
    Expression* right; // 右子表达式
} BinaryData;

// -------------------------- 表达式解释逻辑实现 --------------------------
/// <summary>
/// 终结符：数字表达式的解释逻辑
/// </summary>
int number_interpret(Expression* expr, Context* ctx) {
    if (expr == NULL || ctx == NULL) {
        printf("警告：数字表达式或上下文为空，返回0\n");
        return 0;
    }
    NumberData* data = (NumberData*)expr->data;
    return data->number;
}

/// <summary>
/// 非终结符：加法表达式的解释逻辑
/// </summary>
int add_interpret(Expression* expr, Context* ctx) {
    if (expr == NULL || ctx == NULL) {
        printf("警告：加法表达式或上下文为空，返回0\n");
        return 0;
    }
    BinaryData* data = (BinaryData*)expr->data;
    // 递归调用左右子表达式的解释方法
    return data->left->interpret(data->left, ctx) + data->right->interpret(data->right, ctx);
}

/// <summary>
/// 非终结符：减法表达式的解释逻辑
/// </summary>
int subtract_interpret(Expression* expr, Context* ctx) {
    if (expr == NULL || ctx == NULL) {
        printf("警告：减法表达式或上下文为空，返回0\n");
        return 0;
    }
    BinaryData* data = (BinaryData*)expr->data;
    // 递归调用左右子表达式的解释方法
    return data->left->interpret(data->left, ctx) - data->right->interpret(data->right, ctx);
}

// -------------------------- 表达式创建与释放 --------------------------
/// <summary>
/// 创建数字表达式（终结符）
/// </summary>
Expression* new_number_expr(int number) {
    // 分配表达式结构体内存
    Expression* expr = (Expression*)malloc(sizeof(Expression));
    if (expr == NULL) {
        printf("内存分配失败：创建数字表达式\n");
        return NULL;
    }
    // 分配数字数据内存
    NumberData* data = (NumberData*)malloc(sizeof(NumberData));
    if (data == NULL) {
        printf("内存分配失败：创建数字表达式数据\n");
        free(expr);
        return NULL;
    }
    data->number = number;
    expr->interpret = number_interpret;
    expr->data = data;
    return expr;
}

/// <summary>
/// 创建加法表达式（非终结符）
/// </summary>
Expression* new_add_expr(Expression* left, Expression* right) {
    if (left == NULL || right == NULL) {
        printf("警告：加法表达式的左右子表达式不可为null\n");
        return NULL;
    }
    // 分配表达式结构体内存
    Expression* expr = (Expression*)malloc(sizeof(Expression));
    if (expr == NULL) {
        printf("内存分配失败：创建加法表达式\n");
        return NULL;
    }
    // 分配二元表达式数据内存
    BinaryData* data = (BinaryData*)malloc(sizeof(BinaryData));
    if (data == NULL) {
        printf("内存分配失败：创建加法表达式数据\n");
        free(expr);
        return NULL;
    }
    data->left = left;
    data->right = right;
    expr->interpret = add_interpret;
    expr->data = data;
    return expr;
}

/// <summary>
/// 创建减法表达式（非终结符）
/// </summary>
Expression* new_subtract_expr(Expression* left, Expression* right) {
    if (left == NULL || right == NULL) {
        printf("警告：减法表达式的左右子表达式不可为null\n");
        return NULL;
    }
    // 分配表达式结构体内存
    Expression* expr = (Expression*)malloc(sizeof(Expression));
    if (expr == NULL) {
        printf("内存分配失败：创建减法表达式\n");
        return NULL;
    }
    // 分配二元表达式数据内存
    BinaryData* data = (BinaryData*)malloc(sizeof(BinaryData));
    if (data == NULL) {
        printf("内存分配失败：创建减法表达式数据\n");
        free(expr);
        return NULL;
    }
    data->left = left;
    data->right = right;
    expr->interpret = subtract_interpret;
    expr->data = data;
    return expr;
}

/// <summary>
/// 递归释放表达式内存（避免内存泄漏）
/// </summary>
void free_expr(Expression* expr) {
    if (expr == NULL) return;
    // 判断表达式类型，针对性释放数据
    if (expr->interpret == number_interpret) {
        // 终结符：直接释放数据
        free(expr->data);
    } else {
        // 非终结符：递归释放左右子表达式
        BinaryData* data = (BinaryData*)expr->data;
        free_expr(data->left);
        free_expr(data->right);
        free(data);
    }
    free(expr);
}

// 客户端：构建语法树并执行解析
int main() {
    // 1. 初始化上下文
    Context* ctx = (Context*)malloc(sizeof(Context));
    if (ctx == NULL) {
        printf("内存分配失败：创建上下文\n");
        return -1;
    }

    // 2. 构建语法树：解析表达式 “1 + 2 - 3”
    Expression* addExpr = new_add_expr(new_number_expr(1), new_number_expr(2));
    Expression* subExpr = new_subtract_expr(addExpr, new_number_expr(3));
    if (subExpr == NULL) {
        printf("创建语法树失败\n");
        free_expr(addExpr);
        free(ctx);
        return -1;
    }

    // 3. 执行解析并输出结果
    int result = subExpr->interpret(subExpr, ctx);
    printf("纯C 解析表达式「1 + 2 - 3」，执行结果：%d\n", result); // 输出 0

    // 4. 释放所有资源
    free_expr(subExpr);
    free(ctx);
    return 0;
}

三、解释器模式的优缺点

解释器模式的核心优势是“高扩展性、语法模块化”，但同时存在性能损耗与维护成本的权衡。实际开发中需结合业务场景，判断是否适用该模式，避免过度设计或滥用。

3.1 核心优点

  • 扩展性极强：新增文法规则时，只需新增对应的终结符或非终结符表达式，无需修改现有解析逻辑，完全符合“开闭原则”。例如，在现有加减表达式基础上，新增乘法表达式，仅需实现MultiplyExpression类，无需改动其他代码。

  • 语法解析模块化：将复杂语法拆解为多个简单的表达式节点，每个节点职责单一，代码可读性高、易于理解和维护。例如，算术表达式拆分为数字、加法、减法等节点，每个节点仅处理自身的解析逻辑。

  • 代码复用性高：相同的表达式节点可在不同的语法树中复用，例如数字表达式可同时用于加减乘除等多种运算表达式中，减少代码冗余。

  • 易于实现简单语法：对于固定且简单的文法规则，无需依赖复杂的解析工具，通过解释器模式可快速实现解析逻辑，开发成本低。

3.2 主要缺点

  • 性能损耗较大：语法树的解析依赖递归调用，嵌套层级越深，递归次数越多，性能损耗越明显；同时，每个表达式节点都是独立对象（或结构体），大量节点会占用较多内存，尤其在高频解析场景中，性能瓶颈突出。

  • 维护成本高：若文法规则复杂（如支持乘除、括号、优先级、变量替换等），需定义大量的表达式类/结构体，代码量会急剧增加，后续维护和扩展的成本大幅上升。

  • 适用场景有限：仅适用于固定且简单的文法规则，无法应对动态、复杂的语法解析场景（如完整的编程语言解释器、复杂SQL解析），此类场景更适合使用专业的解析器生成工具（如ANTLR、Yacc）。

  • 调试难度高：语法解析过程是递归执行的，当解析出现异常时，难以定位问题所在，调试成本较高。

四、解释器模式的使用场景

解释器模式的适用场景具有明确的核心前提：文法规则固定且简单，需要自定义语法解析，且对解析性能要求不高。以下结合具体业务场景与实战案例，帮助开发者精准判断适用性，避免滥用。

4.1 核心适用场景

  • 简单表达式计算：如计算器中的加减乘除、逻辑表达式（&&、||、!）解析，自定义公式计算（如业务系统中的折扣计算、积分计算）。

  • 自定义配置解析：解析自定义格式的配置文件，如自定义键值对规则、简单条件配置（如“if 条件A then 执行B”），适用于轻量级配置场景。

  • 领域特定语言（DSL）实现：实现简化版的领域特定语言，如数据库查询语言（简化版SQL）、脚本语言（如Lua子集）、规则引擎中的规则语法（如风控规则、权限规则）。

  • 格式转换与解析：如日期格式解析（如“yyyy-MM-dd”转换为日期对象）、数据格式解析（如自定义协议数据解析）、简单模板解析（如静态模板中的变量替换）。

  • 简单规则执行：业务规则简单且固定的场景，如工作流中的节点跳转规则、消息推送的条件规则，通过解释器模式解析规则并执行。

4.2 不适用场景

  • 复杂语法解析场景（如完整的编程语言解释器、复杂SQL解析）：此类场景文法规则复杂，使用解释器模式会导致代码量激增、维护困难，应使用专业的解析器生成工具。

  • 高频解析、高性能要求场景（如实时数据解析、高并发接口中的表达式计算）：解释器模式的递归解析会导致性能损耗，应使用编译期优化、逆波兰表达式等更高效的方案。

  • 文法规则频繁变更的场景：每次规则变更都需新增或修改表达式节点，维护成本过高，不适合使用解释器模式。

五、总结

解释器模式通过“拆分语法、组合解析”的思路，将复杂的语法解释逻辑拆解为可复用的简单节点，核心价值是简化固定语法的解析逻辑并提供良好的扩展性，其本质是“语法的模块化与多态解析”。该模式让客户端无需关注具体的解析细节，只需构建语法树并调用解释方法，即可完成语法解析与执行。

从多语言实现来看，不同语言的实现风格虽有显著差异，但核心逻辑高度一致：

  • 面向对象语言（C#、Python、C++、Golang）可直接通过接口/抽象类+多态实现，代码结构贴合解释器模式的经典定义，开发高效、可读性强；

  • 纯C语言则通过结构体+函数指针模拟面向对象特性，虽实现过程稍繁琐，但能在资源受限的底层场景中还原模式核心价值，兼顾底层可控性。

在实际开发中，使用解释器模式需重点权衡两个核心点：一是扩展性与维护成本，若文法规则简单且稳定，解释器模式是优雅的选择；若规则复杂，需优先考虑专业解析工具；二是性能与场景适配，高频解析场景需避免使用，优先选择更高效的解析方案。

总之，解释器模式是“简单语法解析”场景下的高效解决方案，掌握其核心结构与多语言实现，能帮助开发者在实际项目中优雅处理自定义语法解析、规则执行等需求，平衡代码设计与工程落地成本，提升系统的可扩展性与可维护性。

发表于 更新于 分类于 ，

备忘录模式（Memento Pattern）是行为型设计模式的重要分支，其核心设计目标是在不破坏对象封装性的前提下，捕获对象的内部状态并将其持久化到外部容器，以便在需要时快速将对象恢复至指定历史状态。该模式完美解决了“状态保存与恢复”的核心痛点，广泛应用于撤销操作、数据回滚、快照备份等场景。本文将从核心结构拆解、多语言落地实现、优缺点深度剖析、适用场景梳理及实战总结等维度，系统解读备忘录模式的设计思想与工程实践，为开发者提供可直接复用的技术方案。

一、备忘录模式核心结构

备忘录模式的核心价值在于“封装状态、解耦管理”，通过三大核心角色的协同工作，实现状态的安全保存与灵活恢复，各角色职责边界清晰，无冗余依赖，具体定义与交互逻辑如下：

1.1 原发器（Originator）

原发器是需要进行状态管理的核心业务对象，负责两个核心操作：一是创建备忘录，即捕获自身当前的内部状态，并将状态写入备忘录对象；二是恢复状态，即从备忘录中读取历史状态，将自身恢复至该状态。原发器是唯一有权限访问备忘录内部状态的角色，确保状态的封装性。

1.2 备忘录（Memento）

备忘录是状态的“容器”，专门用于存储原发器的内部状态，其设计核心是“封装隔离”。为保证状态安全，备忘录仅暴露供原发器读写状态的接口（或仅允许原发器访问其私有状态），其他角色（如管理者）仅能持有备忘录对象，无法修改或直接访问其内部状态，避免破坏原发器的封装性。

1.3 管理者（Caretaker）

管理者是备忘录的“管家”，负责备忘录对象的生命周期管理，包括存储、获取、清理等操作，但不参与状态的读写。管理者的核心作用是解耦原发器与备忘录的直接依赖，通过统一的接口管理多个备忘录，支持多状态快照的存储与切换（如多步撤销）。

核心交互流程：原发器捕获当前状态 → 创建备忘录并写入状态 → 管理者存储备忘录 → 需恢复状态时，管理者取出指定备忘录 → 原发器从备忘录读取状态并完成恢复。

二、多语言实现备忘录模式

以“文本编辑器撤销功能”为统一实战场景，设计核心逻辑：原发器（编辑器）负责存储当前文本内容，备忘录存储文本快照，管理者管理快照列表，支持多步保存与撤销。以下提供C#、Python、Golang、C++及纯C的可运行实现，贴合各语言原生特性，补充规范注释、边界校验与资源释放逻辑，兼顾实用性与严谨性，清晰呈现模式的适配思路。

2.1 C# 实现（面向对象规范实现）

C#作为强类型面向对象语言，通过类封装备忘录状态，依托访问修饰符（private）保证备忘录的封装性，借助泛型与集合优化管理者的备忘录管理逻辑，代码结构清晰、可维护性高，适用于企业级应用的撤销/回滚场景（如办公软件、业务系统配置管理）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
using System;
using System.Collections.Generic;

/// <summary>
/// 备忘录：存储原发器（文本编辑器）的状态，仅允许原发器访问
/// </summary>
public class Memento
{
    /// <summary>
    /// 存储的文本状态（私有字段，仅通过属性供原发器访问）
    /// </summary>
    public string TextState { get; private set; }

    /// <summary>
    /// 构造函数：仅允许原发器创建备忘录（通过访问修饰符控制）
    /// </summary>
    /// <param name="textState">文本编辑器当前状态</param>
    internal Memento(string textState)
    {
        TextState = textState ?? string.Empty; // 避免空值，提升健壮性
    }
}

/// <summary>
/// 原发器：文本编辑器，负责创建/恢复备忘录，管理自身文本状态
/// </summary>
public class Originator
{
    /// <summary>
    /// 编辑器当前文本状态
    /// </summary>
    private string _currentText = string.Empty;

    /// <summary>
    /// 设置编辑器文本状态
    /// </summary>
    /// <param name="text">新文本内容</param>
    public void SetText(string text)
    {
        _currentText = text ?? string.Empty;
        Console.WriteLine($"编辑器更新状态：{_currentText}");
    }

    /// <summary>
    /// 获取当前文本状态
    /// </summary>
    /// <returns>当前文本内容</returns>
    public string GetText() => _currentText;

    /// <summary>
    /// 创建备忘录：捕获当前文本状态，生成快照
    /// </summary>
    /// <returns>包含当前状态的备忘录</returns>
    public Memento CreateMemento()
    {
        return new Memento(_currentText);
    }

    /// <summary>
    /// 从备忘录恢复状态：将编辑器恢复至备忘录存储的历史状态
    /// </summary>
    /// <param name="memento">待恢复的备忘录</param>
    public void RestoreMemento(Memento memento)
    {
        if (memento == null)
        {
            Console.WriteLine("警告：备忘录不可为null，无法恢复状态");
            return;
        }
        _currentText = memento.TextState;
        Console.WriteLine($"编辑器恢复状态：{_currentText}");
    }
}

/// <summary>
/// 管理者：管理备忘录列表，支持多快照存储与获取
/// </summary>
public class Caretaker
{
    /// <summary>
    /// 存储备忘录的队列（FIFO，适配多步撤销场景）
    /// </summary>
    private readonly Queue<Memento> _mementos = new Queue<Memento>();

    /// <summary>
    /// 最大快照数量（避免内存溢出）
    /// </summary>
    private readonly int _maxCount = 10;

    /// <summary>
    /// 添加备忘录快照
    /// </summary>
    /// <param name="memento">待存储的备忘录</param>
    public void AddMemento(Memento memento)
    {
        if (memento == null)
        {
            Console.WriteLine("警告：无法添加空备忘录");
            return;
        }
        // 超过最大快照数量，移除最旧的快照
        if (_mementos.Count >= _maxCount)
        {
            _mementos.Dequeue();
            Console.WriteLine("提示：快照数量已达上限，移除最旧快照");
        }
        _mementos.Enqueue(memento);
        Console.WriteLine($"快照添加成功，当前快照数量：{_mementos.Count}");
    }

    /// <summary>
    /// 获取最新的备忘录快照（适配一步撤销）
    /// </summary>
    /// <returns>最新的备忘录，无快照时返回null</returns>
    public Memento GetLatestMemento()
    {
        if (_mementos.Count == 0)
        {
            Console.WriteLine("警告：无历史快照可获取");
            return null;
        }
        // 队列尾部为最新快照，此处采用ToArray获取最后一个元素（不改变队列结构）
        var mementoArray = _mementos.ToArray();
        return mementoArray[^1];
    }

    /// <summary>
    /// 根据索引获取指定备忘录快照（适配多步撤销）
    /// </summary>
    /// <param name="index">快照索引</param>
    /// <returns>指定索引的备忘录，索引无效时返回null</returns>
    public Memento GetMemento(int index)
    {
        if (index < 0 || index >= _mementos.Count)
        {
            Console.WriteLine("警告：快照索引无效");
            return null;
        }
        return _mementos.ToArray()[index];
    }
}

// 客户端：测试文本编辑器的撤销功能
class Program
{
    static void Main()
    {
        try
        {
            // 1. 初始化组件
            Originator editor = new Originator();
            Caretaker caretaker = new Caretaker();

            // 2. 输入文本并保存快照
            editor.SetText("第1步：编写备忘录模式核心概念");
            caretaker.AddMemento(editor.CreateMemento());

            // 3. 继续输入并保存快照
            editor.SetText("第2步：梳理多语言实现思路");
            caretaker.AddMemento(editor.CreateMemento());

            // 4. 继续输入并保存快照
            editor.SetText("第3步：分析优缺点与使用场景");
            caretaker.AddMemento(editor.CreateMemento());

            // 5. 撤销一步（恢复到第2步状态）
            Console.WriteLine("\n=== 执行一步撤销 ===");
            editor.RestoreMemento(caretaker.GetLatestMemento());

            // 6. 再撤销一步（恢复到第1步状态）
            Console.WriteLine("\n=== 执行第二步撤销 ===");
            editor.RestoreMemento(caretaker.GetMemento(0));
        }
        catch (Exception ex)
        {
            Console.WriteLine($"执行异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（动态语言简洁实现）

Python遵循“鸭子类型”，无需显式定义接口，通过类封装与属性装饰器（@property）保证备忘录的封装性，语法简洁、无冗余类型声明。依托动态特性，可灵活扩展备忘录的状态字段，无需修改核心逻辑，适用于快速开发、轻量级项目（如小型编辑器、配置工具）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
class Memento:
    """备忘录：存储文本编辑器的状态，仅允许原发器访问内部状态"""
    def __init__(self, text_state):
        # 私有字段，通过属性供原发器访问，外部无法直接修改
        self._text_state = text_state or ""

    @property
    def text_state(self):
        """供原发器读取状态的接口"""
        return self._text_state

class Originator:
    """原发器：文本编辑器，负责创建/恢复备忘录，管理自身状态"""
    def __init__(self):
        self._current_text = ""  # 编辑器当前文本状态

    def set_text(self, text):
        """设置编辑器文本状态，处理空值，提升健壮性"""
        self._current_text = text or ""
        print(f"编辑器更新状态：{self._current_text}")

    def get_text(self):
        """获取当前文本状态"""
        return self._current_text

    def create_memento(self):
        """创建备忘录，捕获当前文本状态"""
        return Memento(self._current_text)

    def restore_memento(self, memento):
        """从备忘录恢复状态，校验备忘录合法性"""
        if not isinstance(memento, Memento):
            print("警告：无效的备忘录对象，无法恢复状态")
            return
        self._current_text = memento.text_state
        print(f"编辑器恢复状态：{self._current_text}")

class Caretaker:
    """管理者：管理备忘录列表，支持多快照存储与多步撤销"""
    def __init__(self, max_count=10):
        self._mementos = []  # 存储备忘录的列表
        self._max_count = max_count  # 最大快照数量，避免内存溢出

    def add_memento(self, memento):
        """添加备忘录快照，处理空值与数量上限"""
        if not isinstance(memento, Memento):
            print("警告：无法添加无效的备忘录")
            return
        # 超过最大数量，移除最旧的快照
        if len(self._mementos) >= self._max_count:
            self._mementos.pop(0)
            print("提示：快照数量已达上限，移除最旧快照")
        self._mementos.append(memento)
        print(f"快照添加成功，当前快照数量：{len(self._mementos)}")

    def get_latest_memento(self):
        """获取最新的备忘录快照（一步撤销）"""
        if not self._mementos:
            print("警告：无历史快照可获取")
            return None
        return self._mementos[-1]

    def get_memento(self, index):
        """根据索引获取指定备忘录快照（多步撤销）"""
        if index < 0 or index >= len(self._mementos):
            print("警告：快照索引无效")
            return None
        return self._mementos[index]

# 客户端测试：模拟文本编辑器的撤销流程
if __name__ == "__main__":
    try:
        # 1. 初始化组件
        editor = Originator()
        caretaker = Caretaker(max_count=5)

        # 2. 输入文本并保存快照
        editor.set_text("第1步：编写备忘录模式核心概念")
        caretaker.add_memento(editor.create_memento())

        # 3. 继续输入并保存快照
        editor.set_text("第2步：梳理多语言实现思路")
        caretaker.add_memento(editor.create_memento())

        # 4. 继续输入并保存快照
        editor.set_text("第3步：分析优缺点与使用场景")
        caretaker.add_memento(editor.create_memento())

        # 5. 撤销一步（恢复到第2步状态）
        print("\n=== 执行一步撤销 ===")
        editor.restore_memento(caretaker.get_latest_memento())

        # 6. 再撤销一步（恢复到第1步状态）
        print("\n=== 执行第二步撤销 ===")
        editor.restore_memento(caretaker.get_memento(0))
    except Exception as e:
        print(f"执行异常：{str(e)}")

2.3 Golang 实现（接口至上轻量实现）

Go语言无类和继承，遵循“组合优于继承”原则，通过结构体封装备忘录与原发器状态，依托“小写字段”实现封装（包内可见、包外不可访问），无需额外访问修饰符。代码极简高效，贴合Go语言设计理念，适配高并发后端场景（如分布式系统配置回滚、服务状态快照）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package main

import (
	"fmt"
)

// memento 备忘录：小写字段保证包内访问（封装），仅允许原发器访问状态
type memento struct {
	textState string // 存储的文本状态
}

// Originator 原发器：文本编辑器，负责创建/恢复备忘录
type Originator struct {
	currentText string // 编辑器当前文本状态
}

// SetText 设置编辑器文本状态，处理空值
func (o *Originator) SetText(text string) {
	if text == "" {
		o.currentText = ""
	} else {
		o.currentText = text
	}
	fmt.Printf("编辑器更新状态：%s\n", o.currentText)
}

// GetText 获取当前文本状态
func (o *Originator) GetText() string {
	return o.currentText
}

// CreateMemento 创建备忘录，捕获当前状态
func (o *Originator) CreateMemento() *memento {
	return &memento{textState: o.currentText}
}

// RestoreMemento 从备忘录恢复状态，校验备忘录合法性
func (o *Originator) RestoreMemento(m *memento) {
	if m == nil {
		fmt.Println("警告：备忘录不可为nil，无法恢复状态")
		return
	}
	o.currentText = m.textState
	fmt.Printf("编辑器恢复状态：%s\n", o.currentText)
}

// Caretaker 管理者：管理备忘录列表，支持多快照存储与撤销
type Caretaker struct {
	mementos []*memento // 存储备忘录的切片
	maxCount int        // 最大快照数量
}

// NewCaretaker 初始化管理者，指定最大快照数量
func NewCaretaker(maxCount int) *Caretaker {
	if maxCount <= 0 {
		maxCount = 10 // 默认最大快照数量
	}
	return &Caretaker{
		mementos: make([]*memento, 0, maxCount),
		maxCount: maxCount,
	}
}

// AddMemento 添加备忘录快照，处理数量上限
func (c *Caretaker) AddMemento(m *memento) {
	if m == nil {
		fmt.Println("警告：无法添加空备忘录")
		return
	}
	// 超过最大数量，移除最旧的快照
	if len(c.mementos) >= c.maxCount {
		c.mementos = c.mementos[1:]
		fmt.Println("提示：快照数量已达上限，移除最旧快照")
	}
	c.mementos = append(c.mementos, m)
	fmt.Printf("快照添加成功，当前快照数量：%d\n", len(c.mementos))
}

// GetLatestMemento 获取最新的备忘录快照（一步撤销）
func (c *Caretaker) GetLatestMemento() *memento {
	if len(c.mementos) == 0 {
		fmt.Println("警告：无历史快照可获取")
		return nil
	}
	return c.mementos[len(c.mementos)-1]
}

// GetMemento 根据索引获取指定备忘录快照（多步撤销）
func (c *Caretaker) GetMemento(index int) *memento {
	if index < 0 || index >= len(c.mementos) {
		fmt.Println("警告：快照索引无效")
		return nil
	}
	return c.mementos[index]
}

// 客户端测试：模拟文本编辑器撤销流程
func main() {
	// 1. 初始化组件
	editor := &Originator{}
	caretaker := NewCaretaker(5)

	// 2. 输入文本并保存快照
	editor.SetText("第1步：编写备忘录模式核心概念")
	caretaker.AddMemento(editor.CreateMemento())

	// 3. 继续输入并保存快照
	editor.SetText("第2步：梳理多语言实现思路")
	caretaker.AddMemento(editor.CreateMemento())

	// 4. 继续输入并保存快照
	editor.SetText("第3步：分析优缺点与使用场景")
	caretaker.AddMemento(editor.CreateMemento())

	// 5. 撤销一步（恢复到第2步状态）
	fmt.Println("\n=== 执行一步撤销 ===")
	editor.RestoreMemento(caretaker.GetLatestMemento())

	// 6. 再撤销一步（恢复到第1步状态）
	fmt.Println("\n=== 执行第二步撤销 ===")
	editor.RestoreMemento(caretaker.GetMemento(0))
}

2.4 C++ 实现（抽象类+友元经典实现）

C++通过类与友元机制实现备忘录的封装性，将原发器声明为备忘录的友元，确保只有原发器能访问备忘录的私有状态；同时通过虚析构函数与手动内存管理，避免内存泄漏。该实现兼顾灵活性与高性能，适用于底层开发、高频调用场景（如编译器撤销功能、嵌入式设备配置回滚）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 前向声明：让管理者识别备忘录
class Memento;

/// <summary>
/// 原发器：文本编辑器，负责创建/恢复备忘录
/// 声明为Memento的友元，有权访问其私有状态
/// </summary>
class Originator {
private:
    string currentText; // 编辑器当前文本状态
public:
    Originator() : currentText("") {}

    /// <summary>
    /// 设置编辑器文本状态
    /// </summary>
    void setText(const string& text) {
        currentText = text.empty() ? "" : text;
        cout << "编辑器更新状态：" << currentText << endl;
    }

    /// <summary>
    /// 获取当前文本状态
    /// </summary>
    string getText() const {
        return currentText;
    }

    /// <summary>
    /// 创建备忘录，捕获当前状态
    /// </summary>
    Memento* createMemento();

    /// <summary>
    /// 从备忘录恢复状态
    /// </summary>
    void restoreMemento(Memento* m);
};

/// <summary>
/// 备忘录：存储文本状态，仅允许原发器访问私有成员
/// </summary>
class Memento {
private:
    string textState; // 存储的文本状态
    // 友元声明：仅Originator可访问私有成员
    friend class Originator;

    /// <summary>
    /// 私有构造函数：仅允许原发器创建备忘录
    /// </summary>
    Memento(const string& state) : textState(state) {}

    /// <summary>
    /// 私有接口：供原发器读取状态
    /// </summary>
    string getTextState() const {
        return textState;
    }
};

// 实现原发器的备忘录方法
Memento* Originator::createMemento() {
    return new Memento(currentText);
}

void Originator::restoreMemento(Memento* m) {
    if (m == nullptr) {
        cout << "警告：备忘录不可为nullptr，无法恢复状态" << endl;
        return;
    }
    currentText = m->getTextState();
    cout << "编辑器恢复状态：" << currentText << endl;
}

/// <summary>
/// 管理者：管理备忘录列表，负责内存释放
/// </summary>
class Caretaker {
private:
    vector<Memento*> mementos; // 存储备忘录指针的容器
    int maxCount; // 最大快照数量
public:
    Caretaker(int maxCount = 10) : maxCount(maxCount) {}

    /// <summary>
    /// 析构函数：释放所有备忘录内存，避免泄漏
    /// </summary>
    ~Caretaker() {
        for (auto m : mementos) {
            delete m;
            m = nullptr;
        }
        mementos.clear();
    }

    /// <summary>
    /// 添加备忘录快照
    /// </summary>
    void addMemento(Memento* m) {
        if (m == nullptr) {
            cout << "警告：无法添加空备忘录" << endl;
            return;
        }
        // 超过最大数量，移除最旧的快照并释放内存
        if (mementos.size() >= maxCount) {
            delete mementos[0];
            mementos[0] = nullptr;
            mementos.erase(mementos.begin());
            cout << "提示：快照数量已达上限，移除最旧快照" << endl;
        }
        mementos.push_back(m);
        cout << "快照添加成功，当前快照数量：" << mementos.size() << endl;
    }

    /// <summary>
    /// 获取最新的备忘录快照
    /// </summary>
    Memento* getLatestMemento() {
        if (mementos.empty()) {
            cout << "警告：无历史快照可获取" << endl;
            return nullptr;
        }
        return mementos.back();
    }

    /// <summary>
    /// 根据索引获取指定备忘录快照
    /// </summary>
    Memento* getMemento(int index) {
        if (index < 0 || index >= (int)mementos.size()) {
            cout << "警告：快照索引无效" << endl;
            return nullptr;
        }
        return mementos[index];
    }
};

// 客户端测试：模拟文本编辑器撤销流程
int main() {
    try {
        // 1. 初始化组件
        Originator* editor = new Originator();
        Caretaker* caretaker = new Caretaker(5);

        // 2. 输入文本并保存快照
        editor->setText("第1步：编写备忘录模式核心概念");
        caretaker->addMemento(editor->createMemento());

        // 3. 继续输入并保存快照
        editor->setText("第2步：梳理多语言实现思路");
        caretaker->addMemento(editor->createMemento());

        // 4. 继续输入并保存快照
        editor->setText("第3步：分析优缺点与使用场景");
        caretaker->addMemento(editor->createMemento());

        // 5. 撤销一步（恢复到第2步状态）
        cout << "\n=== 执行一步撤销 ===" << endl;
        editor->restoreMemento(caretaker->getLatestMemento());

        // 6. 再撤销一步（恢复到第1步状态）
        cout << "\n=== 执行第二步撤销 ===" << endl;
        editor->restoreMemento(caretaker->getMemento(0));

        // 释放资源
        delete editor;
        delete caretaker;
        editor = nullptr;
        caretaker = nullptr;
    } catch (const exception& e) {
        cout << "执行异常：" << e.what() << endl;
    }
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C无面向对象特性，通过“结构体封装数据+函数指针封装行为”模拟备忘录模式的核心逻辑，依托命名约定（前缀下划线）模拟私有字段，通过函数接口控制状态的读写权限，底层可控性强、无额外依赖。适用于嵌入式、底层开发等资源受限场景，完整还原模式“封装状态、解耦管理”的核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 前向声明：解决结构体与函数指针的交叉引用
typedef struct Memento Memento;
typedef struct Originator Originator;
typedef struct Caretaker Caretaker;

/// <summary>
/// 备忘录结构体：模拟私有字段（下划线前缀），仅通过接口供原发器访问
/// </summary>
typedef struct Memento {
    char* _text_state; // 存储的文本状态（模拟私有字段）
} Memento;

/// <summary>
/// 原发器结构体：文本编辑器，封装状态与方法指针
/// </summary>
typedef struct Originator {
    char* current_text; // 当前文本状态
    // 方法指针：模拟类的成员方法
    Memento* (*create_memento)(Originator*);    // 创建备忘录
    void (*restore_memento)(Originator*, Memento*); // 恢复状态
} Originator;

/// <summary>
/// 管理者结构体：管理备忘录列表
/// </summary>
typedef struct Caretaker {
    Memento** mementos; // 存储备忘录指针的数组
    int count;          // 当前快照数量
    int capacity;       // 数组容量
    int max_count;      // 最大快照数量
} Caretaker;

// -------------------------- 备忘录工具函数 --------------------------
/// <summary>
/// 创建备忘录，初始化状态
/// </summary>
Memento* memento_create(const char* text_state) {
    Memento* m = (Memento*)malloc(sizeof(Memento));
    if (m == NULL) return NULL;
    // 处理空值，避免野指针
    int len = text_state ? strlen(text_state) : 0;
    m->_text_state = (char*)malloc(len + 1);
    if (m->_text_state == NULL) {
        free(m);
        return NULL;
    }
    strcpy(m->_text_state, text_state ? text_state : "");
    return m;
}

/// <summary>
/// 销毁备忘录，释放内存
/// </summary>
void memento_destroy(Memento* m) {
    if (m == NULL) return;
    free(m->_text_state);
    free(m);
}

/// <summary>
/// 供原发器读取备忘录状态的接口（模拟私有字段访问）
/// </summary>
const char* memento_get_text_state(Memento* m) {
    if (m == NULL) return "";
    return m->_text_state;
}

// -------------------------- 原发器方法实现 --------------------------
/// <summary>
/// 原发器：创建备忘录，捕获当前状态
/// </summary>
Memento* originator_create_memento(Originator* o) {
    if (o == NULL) return NULL;
    return memento_create(o->current_text);
}

/// <summary>
/// 原发器：从备忘录恢复状态
/// </summary>
void originator_restore_memento(Originator* o, Memento* m) {
    if (o == NULL || m == NULL) {
        printf("警告：原发器或备忘录为空，无法恢复状态\n");
        return;
    }
    // 释放原有状态内存，避免泄漏
    if (o->current_text != NULL) {
        free(o->current_text);
    }
    // 复制备忘录中的状态
    const char* state = memento_get_text_state(m);
    int len = strlen(state);
    o->current_text = (char*)malloc(len + 1);
    strcpy(o->current_text, state);
    printf("编辑器恢复状态：%s\n", o->current_text);
}

/// <summary>
/// 原发器：设置文本状态
/// </summary>
void originator_set_text(Originator* o, const char* text) {
    if (o == NULL) return;
    // 释放原有状态内存
    if (o->current_text != NULL) {
        free(o->current_text);
    }
    // 处理空值
    int len = text ? strlen(text) : 0;
    o->current_text = (char*)malloc(len + 1);
    strcpy(o->current_text, text ? text : "");
    printf("编辑器更新状态：%s\n", o->current_text);
}

/// <summary>
/// 初始化原发器
/// </summary>
Originator* originator_init() {
    Originator* o = (Originator*)malloc(sizeof(Originator));
    if (o == NULL) return NULL;
    o->current_text = NULL;
    o->create_memento = originator_create_memento;
    o->restore_memento = originator_restore_memento;
    // 初始化状态为空字符串
    originator_set_text(o, "");
    return o;
}

// -------------------------- 管理者方法实现 --------------------------
/// <summary>
/// 初始化管理者
/// </summary>
Caretaker* caretaker_init(int max_count) {
    Caretaker* c = (Caretaker*)malloc(sizeof(Caretaker));
    if (c == NULL) return NULL;
    // 默认最大快照数量为10
    c->max_count = max_count <= 0 ? 10 : max_count;
    c->capacity = c->max_count;
    c->count = 0;
    c->mementos = (Memento**)malloc(sizeof(Memento*) * c->capacity);
    if (c->mementos == NULL) {
        free(c);
        return NULL;
    }
    return c;
}

/// <summary>
/// 管理者：添加备忘录快照
/// </summary>
void caretaker_add_memento(Caretaker* c, Memento* m) {
    if (c == NULL || m == NULL) {
        printf("警告：管理者或备忘录为空，无法添加快照\n");
        return;
    }
    // 超过最大数量，移除最旧快照并释放内存
    if (c->count >= c->max_count) {
        memento_destroy(c->mementos[0]);
        // 移动数组，移除第一个元素
        for (int i = 0; i < c->count - 1; i++) {
            c->mementos[i] = c->mementos[i + 1];
        }
        c->count--;
        printf("提示：快照数量已达上限，移除最旧快照\n");
    }
    c->mementos[c->count++] = m;
    printf("快照添加成功，当前快照数量：%d\n", c->count);
}

/// <summary>
/// 管理者：获取最新的备忘录快照
/// </summary>
Memento* caretaker_get_latest_memento(Caretaker* c) {
    if (c == NULL || c->count == 0) {
        printf("警告：无历史快照可获取\n");
        return NULL;
    }
    return c->mementos[c->count - 1];
}

/// <summary>
/// 管理者：根据索引获取指定备忘录快照
/// </summary>
Memento* caretaker_get_memento(Caretaker* c, int index) {
    if (c == NULL || index < 0 || index >= c->count) {
        printf("警告：快照索引无效\n");
        return NULL;
    }
    return c->mementos[index];
}

/// <summary>
/// 释放所有资源
/// </summary>
void cleanup(Originator* o, Caretaker* c) {
    // 释放原发器资源
    if (o != NULL) {
        if (o->current_text != NULL) {
            free(o->current_text);
        }
        free(o);
    }
    // 释放管理者与备忘录资源
    if (c != NULL) {
        for (int i = 0; i < c->count; i++) {
            memento_destroy(c->mementos[i]);
        }
        free(c->mementos);
        free(c);
    }
}

// 客户端测试：模拟文本编辑器撤销流程
int main() {
    // 1. 初始化组件
    Originator* editor = originator_init();
    Caretaker* caretaker = caretaker_init(5);
    if (editor == NULL || caretaker == NULL) {
        printf("初始化失败，退出程序\n");
        cleanup(editor, caretaker);
        return -1;
    }

    // 2. 输入文本并保存快照
    originator_set_text(editor, "第1步：编写备忘录模式核心概念");
    caretaker_add_memento(caretaker, editor->create_memento(editor));

    // 3. 继续输入并保存快照
    originator_set_text(editor, "第2步：梳理多语言实现思路");
    caretaker_add_memento(caretaker, editor->create_memento(editor));

    // 4. 继续输入并保存快照
    originator_set_text(editor, "第3步：分析优缺点与使用场景");
    caretaker_add_memento(caretaker, editor->create_memento(editor));

    // 5. 撤销一步（恢复到第2步状态）
    printf("\n=== 执行一步撤销 ===\n");
    editor->restore_memento(editor, caretaker_get_latest_memento(caretaker));

    // 6. 再撤销一步（恢复到第1步状态）
    printf("\n=== 执行第二步撤销 ===\n");
    editor->restore_memento(editor, caretaker_get_memento(caretaker, 0));

    // 7. 释放所有资源
    cleanup(editor, caretaker);
    return 0;
}

三、备忘录模式的优缺点

备忘录模式的核心优势的是“封装状态、灵活回滚”，但同时存在资源消耗与维护成本的权衡。实际开发中需结合业务场景，平衡设计优雅与工程落地成本，避免过度设计或滥用。

3.1 核心优点

  • 封装性极佳：备忘录仅允许原发器访问内部状态，外部角色（如管理者）无法直接修改或访问，完美遵循“封装原则”，保证状态数据的安全性。

  • 状态回滚灵活：支持多步快照的保存与恢复，可轻松实现撤销、回滚、快照备份等功能，无需修改原发器核心逻辑，适配多场景状态管理需求。

  • 职责划分清晰：原发器负责状态管理，备忘录负责状态存储，管理者负责备忘录生命周期管理，三者各司其职、解耦关联，符合“单一职责原则”，提升代码可维护性。

  • 扩展性良好：新增状态字段或扩展快照功能时，仅需修改原发器与备忘录，无需改动管理者，对现有业务逻辑侵入性低。

3.2 主要缺点

  • 资源消耗较大：若原发器状态字段多、快照保存频繁，会产生大量备忘录对象，占用内存资源；尤其在高频保存场景（如实时编辑器），可能引发性能瓶颈。

  • 维护成本较高：若原发器的状态结构发生变更（如新增/删除字段），备忘录需同步修改，管理者的存储逻辑也可能需要调整，增加维护成本。

  • 并发安全风险：多线程环境下，多个线程同时读写备忘录或原发器状态，可能引发线程安全问题，需额外添加锁机制，增加代码复杂度。

  • 序列化成本高：若需持久化备忘录（如存储到文件、数据库），需实现序列化/反序列化逻辑，尤其对于复杂状态，序列化成本较高。

四、备忘录模式的使用场景

备忘录模式的适用场景具有明确的核心前提：需要保存对象历史状态，且需支持状态回滚，同时要求不破坏对象封装性。以下结合具体业务场景与实战案例，帮助开发者精准判断适用性，避免滥用。

4.1 核心适用场景

  • 撤销/回滚操作场景：最典型的场景是文本编辑器、表格软件的撤销功能，每输入一步保存一个快照，支持多步撤销；此外，数据库事务回滚、代码版本回滚也属于此类场景。

  • 状态快照备份场景：如游戏存档（保存角色等级、装备、进度等状态）、虚拟机快照（保存虚拟机运行状态）、系统配置快照（保存系统当前配置），支持后续恢复至指定状态。

  • 业务流程回溯场景：如审批流程中，保存每个节点的状态，支持回溯到任意节点重新处理；订单流程中，保存订单的状态变更记录，便于异常时回滚至正常状态。

  • 测试场景：自动化测试中，保存测试用例的初始状态，执行测试后恢复至初始状态，避免测试用例之间的相互影响。

4.2 不适用场景

  • 对象状态简单、无需回滚的场景，使用备忘录模式会增加代码复杂度，直接通过变量存储状态更高效。

  • 状态频繁变更且状态量极大的场景（如实时日志、高频数据采集），大量备忘录会占用过多内存，导致性能下降。

  • 对象封装性要求极低，允许外部直接访问状态的场景，无需通过备忘录间接管理状态。

五、总结

备忘录模式通过“原发器-备忘录-管理者”的三元结构，优雅地解决了“状态保存与恢复”的核心痛点，其核心设计思想是在不破坏对象封装性的前提下，实现状态的安全存储与灵活回滚。该模式的本质是“状态的隔离与管理”，让原发器专注于核心业务逻辑，将状态的存储与恢复交给备忘录和管理者，提升代码的可维护性与扩展性。

不同语言对备忘录模式的实现风格虽有显著差异，但核心逻辑高度一致：面向对象语言（C#、Python、Golang、C++）依托类、接口、友元等特性，轻松实现状态封装与访问控制，代码结构清晰；纯C语言则通过结构体+函数指针模拟面向对象特性，虽实现繁琐，但能在资源受限场景中还原模式核心价值，兼顾底层可控性。

使用备忘录模式时，需重点权衡两个核心点：一是资源消耗，对于高频保存、状态量大的场景，可优化为增量快照（仅保存状态变化部分）或定期清理过期快照，避免内存溢出；二是维护成本，若原发器状态频繁变更，需谨慎使用，避免因状态结构调整导致的大量代码修改。

总之，备忘录模式是“状态管理与回滚”场景下的最优解决方案之一，掌握其核心结构与多语言实现，能帮助开发者在实际项目中优雅处理撤销、快照、回滚等需求，平衡代码设计与工程落地成本，提升系统的健壮性与可扩展性。

发表于 更新于 分类于 ，

访问者模式（Visitor Pattern）是行为型设计模式的核心范式之一，核心思想是分离数据结构与数据操作，在不修改现有数据结构的前提下，灵活扩展新的操作逻辑。该模式通过引入“访问者”角色，将对数据的操作封装为独立实体，让数据结构专注于数据存储，操作逻辑专注于业务处理，尤其适用于数据结构稳定但操作频繁变化的场景。本文将从核心结构、多语言落地实现、优缺点剖析、适用场景及实战总结等维度，系统拆解访问者模式的设计思路与工程实践，为开发者提供可直接复用的技术方案。

一、访问者模式核心结构

访问者模式的核心是通过五大角色的协同，实现“数据与操作”的解耦，各角色职责边界清晰、分工明确，共同构成完整的设计闭环。理解各角色的作用与交互逻辑，是掌握该模式的关键，具体定义如下：

1.1 抽象元素（Element）

抽象元素是数据结构的抽象契约，定义了一个核心方法——接受访问者的Accept方法。该方法的核心作用是将自身作为参数，传递给访问者，触发访问者对当前元素的具体操作，是元素与访问者建立关联的桥梁。

1.2 具体元素（ConcreteElement）

具体元素是抽象元素的具象化实现，负责存储具体数据，并实现Accept方法。其核心逻辑是：在Accept方法中调用访问者对应的访问方法，将自身实例传递给访问者，完成操作的委托执行，确保访问者能获取元素的内部数据并执行处理。

1.3 抽象访问者（Visitor）

抽象访问者是操作逻辑的抽象契约，为每一种具体元素类型声明一个对应的访问方法（如VisitConcreteElementA）。访问方法的参数为对应类型的具体元素，确保访问者能精准操作不同类型的元素，同时规范所有具体访问者的实现标准。

1.4 具体访问者（ConcreteVisitor）

具体访问者是抽象访问者的具象化实现，负责实现抽象访问者声明的所有访问方法，定义对不同具体元素的差异化操作逻辑。一个具体访问者对应一套完整的操作逻辑，新增操作只需新增具体访问者，无需修改现有代码。

1.5 对象结构（ObjectStructure）

对象结构是元素的容器，负责管理所有具体元素的集合，提供元素的添加、删除和遍历方法。其核心作用是统一接收访问者，遍历所有元素并触发元素的Accept方法，让访问者能批量处理集合中的所有元素，简化客户端调用逻辑。

核心交互逻辑：客户端创建对象结构→添加具体元素→创建具体访问者→对象结构接收访问者→遍历元素，触发元素Accept方法→元素调用访问者对应方法→访问者执行具体操作。

二、多语言实现访问者模式

以“数据处理工具”为统一实战场景，设计两类具体元素（ConcreteElementA存储基础数值，ConcreteElementB存储运算数值），两类具体访问者（基础数据查看、数据运算处理），通过对象结构管理元素集合。以下提供C#、Python、Golang、C++及纯C的可运行实现，贴合各语言原生特性，补充规范注释与边界校验，兼顾实用性与严谨性，清晰呈现模式适配思路。

2.1 C# 实现（面向对象规范实现）

C#作为强类型面向对象语言，通过接口定义抽象元素与抽象访问者，依托多态特性实现操作的动态分发，代码结构清晰、可维护性高，适用于企业级业务系统中“数据结构固定、操作易扩展”的场景（如报表生成、数据统计）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
using System;
using System.Collections.Generic;

/// <summary>
/// 抽象访问者：定义对所有具体元素的访问契约
/// </summary>
public interface IVisitor
{
    /// <summary>访问具体元素A</summary>
    /// <param name="elementA">具体元素A实例</param>
    void VisitConcreteElementA(ConcreteElementA elementA);
    
    /// <summary>访问具体元素B</summary>
    /// <param name="elementB">具体元素B实例</param>
    void VisitConcreteElementB(ConcreteElementB elementB);
}

/// <summary>
/// 具体访问者1：基础数据查看操作
/// 核心逻辑：仅展示元素的原始数据，无额外运算
/// </summary>
public class ConcreteVisitor1 : IVisitor
{
    public void VisitConcreteElementA(ConcreteElementA elementA)
    {
        Console.WriteLine($"【{GetType().Name}】处理 {elementA.GetType().Name}，原始数据：{elementA.Data}");
    }

    public void VisitConcreteElementB(ConcreteElementB elementB)
    {
        Console.WriteLine($"【{GetType().Name}】处理 {elementB.GetType().Name}，原始数据：{elementB.Value}");
    }
}

/// <summary>
/// 具体访问者2：数据运算处理操作
/// 核心逻辑：对元素数据执行差异化运算（翻倍、平方）
/// </summary>
public class ConcreteVisitor2 : IVisitor
{
    public void VisitConcreteElementA(ConcreteElementA elementA)
    {
        int result = elementA.Data * 2;
        Console.WriteLine($"【{GetType().Name}】处理 {elementA.GetType().Name}，数据翻倍结果：{result}");
    }

    public void VisitConcreteElementB(ConcreteElementB elementB)
    {
        int result = elementB.Value * elementB.Value;
        Console.WriteLine($"【{GetType().Name}】处理 {elementB.GetType().Name}，数据平方结果：{result}");
    }
}

/// <summary>
/// 抽象元素：定义接受访问者的核心方法
/// </summary>
public interface IElement
{
    /// <summary>接受访问者访问，触发对应操作</summary>
    /// <param name="visitor">访问者实例</param>
    void Accept(IVisitor visitor);
}

/// <summary>
/// 具体元素A：存储基础数值数据
/// </summary>
public class ConcreteElementA : IElement
{
    /// <summary>元素核心数据</summary>
    public int Data { get; set; } = 10;

    /// <summary>接受访问者，委托执行对应操作</summary>
    public void Accept(IVisitor visitor)
    {
        visitor.VisitConcreteElementA(this);
    }
}

/// <summary>
/// 具体元素B：存储运算数值数据
/// </summary>
public class ConcreteElementB : IElement
{
    /// <summary>元素核心数据</summary>
    public int Value { get; set; } = 5;

    /// <summary>接受访问者，委托执行对应操作</summary>
    public void Accept(IVisitor visitor)
    {
        visitor.VisitConcreteElementB(this);
    }
}

/// <summary>
/// 对象结构：管理元素集合，提供批量访问入口
/// </summary>
public class ObjectStructure
{
    // 存储元素的集合
    private readonly List<IElement> _elements = new List<IElement>();

    /// <summary>添加元素到集合</summary>
    public void AddElement(IElement element)
    {
        if (element == null)
        {
            Console.WriteLine("警告：添加的元素不可为null");
            return;
        }
        _elements.Add(element);
    }

    /// <summary>接受访问者，遍历所有元素执行操作</summary>
    public void Accept(IVisitor visitor)
    {
        if (visitor == null)
        {
            Console.WriteLine("警告：访问者不可为null");
            return;
        }
        foreach (var element in _elements)
        {
            element.Accept(visitor);
        }
    }
}

// 客户端：测试访问者模式的核心交互逻辑
class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 1. 创建对象结构（元素容器）
            ObjectStructure structure = new ObjectStructure();
            // 2. 添加具体元素
            structure.AddElement(new ConcreteElementA());
            structure.AddElement(new ConcreteElementB());

            // 3. 创建具体访问者1（基础数据查看）
            IVisitor visitor1 = new ConcreteVisitor1();
            Console.WriteLine("=== 执行基础数据查看操作 ===");
            structure.Accept(visitor1);

            // 4. 创建具体访问者2（数据运算处理）
            IVisitor visitor2 = new ConcreteVisitor2();
            Console.WriteLine("\n=== 执行数据运算处理操作 ===");
            structure.Accept(visitor2);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"执行异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（动态语言简洁实现）

Python遵循“鸭子类型”，无需显式定义接口，通过抽象基类（ABC）约定元素与访问者的行为，语法简洁、无冗余类型声明。依托动态特性，可灵活扩展元素与访问者，无需严格的类型校验，适用于快速开发、轻量级项目（如数据处理脚本）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
from abc import ABC, abstractmethod

class Visitor(ABC):
    """抽象访问者：通过抽象方法约定访问行为"""
    @abstractmethod
    def visit_concrete_element_a(self, element):
        """访问具体元素A"""
        pass

    @abstractmethod
    def visit_concrete_element_b(self, element):
        """访问具体元素B"""
        pass

class ConcreteVisitor1(Visitor):
    """具体访问者1：基础数据查看操作"""
    def visit_concrete_element_a(self, element):
        print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，原始数据：{element.data}")

    def visit_concrete_element_b(self, element):
        print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，原始数据：{element.value}")

class ConcreteVisitor2(Visitor):
    """具体访问者2：数据运算处理操作"""
    def visit_concrete_element_a(self, element):
        result = element.data * 2
        print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，数据翻倍结果：{result}")

    def visit_concrete_element_b(self, element):
        result = element.value ** 2
        print(f"【{self.__class__.__name__}】处理 {element.__class__.__name__}，数据平方结果：{result}")

class Element(ABC):
    """抽象元素：约定接受访问者的方法"""
    @abstractmethod
    def accept(self, visitor):
        """接受访问者访问"""
        pass

class ConcreteElementA(Element):
    """具体元素A：存储基础数值数据"""
    def __init__(self):
        self.data = 10  # 元素核心数据

    def accept(self, visitor):
        # 委托访问者执行对应操作，传递自身实例
        visitor.visit_concrete_element_a(self)

class ConcreteElementB(Element):
    """具体元素B：存储运算数值数据"""
    def __init__(self):
        self.value = 5  # 元素核心数据

    def accept(self, visitor):
        # 委托访问者执行对应操作，传递自身实例
        visitor.visit_concrete_element_b(self)

class ObjectStructure:
    """对象结构：管理元素集合，提供批量访问入口"""
    def __init__(self):
        self.elements = []  # 存储元素的集合

    def add_element(self, element):
        """添加元素到集合，校验元素合法性"""
        if not isinstance(element, Element):
            raise TypeError("添加的元素必须是Element子类实例")
        self.elements.append(element)

    def accept(self, visitor):
        """接受访问者，遍历所有元素执行操作"""
        if not isinstance(visitor, Visitor):
            raise TypeError("访问者必须是Visitor子类实例")
        for element in self.elements:
            element.accept(visitor)

# 客户端测试
if __name__ == "__main__":
    try:
        # 1. 创建对象结构并添加元素
        structure = ObjectStructure()
        structure.add_element(ConcreteElementA())
        structure.add_element(ConcreteElementB())

        # 2. 执行基础数据查看操作
        visitor1 = ConcreteVisitor1()
        print("=== 执行基础数据查看操作 ===")
        structure.accept(visitor1)

        # 3. 执行数据运算处理操作
        visitor2 = ConcreteVisitor2()
        print("\n=== 执行数据运算处理操作 ===")
        structure.accept(visitor2)
    except Exception as e:
        print(f"执行异常：{str(e)}")

2.3 Golang 实现（接口至上轻量实现）

Go语言无类和继承，遵循“组合优于继承”原则，通过接口定义抽象元素与抽象访问者的契约，结构体实现接口方法完成具体逻辑。依托接口隐式实现特性，代码极简高效，贴合Go语言设计理念，适配高并发后端场景（如数据批量处理、中间件扩展）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package main

import "fmt"

// Visitor 抽象访问者接口：定义访问所有具体元素的方法
type Visitor interface {
	VisitConcreteElementA(element *ConcreteElementA) // 访问具体元素A
	VisitConcreteElementB(element *ConcreteElementB) // 访问具体元素B
}

// ConcreteVisitor1 具体访问者1：基础数据查看操作
type ConcreteVisitor1 struct{}

// VisitConcreteElementA 处理具体元素A，查看原始数据
func (v *ConcreteVisitor1) VisitConcreteElementA(element *ConcreteElementA) {
	fmt.Printf("【ConcreteVisitor1】处理 ConcreteElementA，原始数据：%d\n", element.Data)
}

// VisitConcreteElementB 处理具体元素B，查看原始数据
func (v *ConcreteVisitor1) VisitConcreteElementB(element *ConcreteElementB) {
	fmt.Printf("【ConcreteVisitor1】处理 ConcreteElementB，原始数据：%d\n", element.Value)
}

// ConcreteVisitor2 具体访问者2：数据运算处理操作
type ConcreteVisitor2 struct{}

// VisitConcreteElementA 处理具体元素A，数据翻倍
func (v *ConcreteVisitor2) VisitConcreteElementA(element *ConcreteElementA) {
	result := element.Data * 2
	fmt.Printf("【ConcreteVisitor2】处理 ConcreteElementA，数据翻倍结果：%d\n", result)
}

// VisitConcreteElementB 处理具体元素B，数据平方
func (v *ConcreteVisitor2) VisitConcreteElementB(element *ConcreteElementB) {
	result := element.Value * element.Value
	fmt.Printf("【ConcreteVisitor2】处理 ConcreteElementB，数据平方结果：%d\n", result)
}

// Element 抽象元素接口：定义接受访问者的方法
type Element interface {
	Accept(visitor Visitor) // 接受访问者访问
}

// ConcreteElementA 具体元素A：存储基础数值数据
type ConcreteElementA struct {
	Data int // 元素核心数据
}

// Accept 接受访问者，委托执行对应操作
func (e *ConcreteElementA) Accept(visitor Visitor) {
	visitor.VisitConcreteElementA(e)
}

// ConcreteElementB 具体元素B：存储运算数值数据
type ConcreteElementB struct {
	Value int // 元素核心数据
}

// Accept 接受访问者，委托执行对应操作
func (e *ConcreteElementB) Accept(visitor Visitor) {
	visitor.VisitConcreteElementB(e)
}

// ObjectStructure 对象结构：管理元素集合，提供批量访问入口
type ObjectStructure struct {
	elements []Element // 存储元素的切片
}

// AddElement 添加元素到集合，校验元素合法性
func (os *ObjectStructure) AddElement(element Element) {
	if element == nil {
		fmt.Println("警告：添加的元素不可为nil")
		return
	}
	os.elements = append(os.elements, element)
}

// Accept 接受访问者，遍历所有元素执行操作
func (os *ObjectStructure) Accept(visitor Visitor) {
	if visitor == nil {
		fmt.Println("警告：访问者不可为nil")
		return
	}
	for _, element := range os.elements {
		element.Accept(visitor)
	}
}

// 客户端测试
func main() {
	// 1. 创建对象结构并添加元素
	structure := &ObjectStructure{}
	structure.AddElement(&ConcreteElementA{Data: 10})
	structure.AddElement(&ConcreteElementB{Value: 5})

	// 2. 执行基础数据查看操作
	visitor1 := &ConcreteVisitor1{}
	fmt.Println("=== 执行基础数据查看操作 ===")
	structure.Accept(visitor1)

	// 3. 执行数据运算处理操作
	visitor2 := &ConcreteVisitor2{}
	fmt.Println("\n=== 执行数据运算处理操作 ===")
	structure.Accept(visitor2)
}

2.4 C++ 实现（抽象类+多态经典实现）

C++通过抽象类（纯虚函数）定义抽象元素与抽象访问者，子类继承并实现具体逻辑，依托多态特性实现操作的动态分发，是访问者模式的经典实现方式。需手动管理内存（虚析构函数避免内存泄漏），兼顾灵活性与高性能，适用于底层开发、高频调用场景（如编译器语法树处理、嵌入式数据解析）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include <iostream>
#include <vector>
using namespace std;

// 前向声明具体元素，解决抽象访问者与具体元素的交叉引用问题
class ConcreteElementA;
class ConcreteElementB;

/// <summary>
/// 抽象访问者：纯虚函数定义访问契约
/// </summary>
class Visitor {
public:
    virtual ~Visitor() = default; // 虚析构函数，避免多态内存泄漏
    // 访问具体元素A的纯虚方法
    virtual void VisitConcreteElementA(ConcreteElementA* element) = 0;
    // 访问具体元素B的纯虚方法
    virtual void VisitConcreteElementB(ConcreteElementB* element) = 0;
};

/// <summary>
/// 具体访问者1：基础数据查看操作
/// </summary>
class ConcreteVisitor1 : public Visitor {
public:
    void VisitConcreteElementA(ConcreteElementA* element) override;
    void VisitConcreteElementB(ConcreteElementB* element) override;
};

/// <summary>
/// 具体访问者2：数据运算处理操作
/// </summary>
class ConcreteVisitor2 : public Visitor {
public:
    void VisitConcreteElementA(ConcreteElementA* element) override;
    void VisitConcreteElementB(ConcreteElementB* element) override;
};

/// <summary>
/// 抽象元素：纯虚函数定义接受访问者的方法
/// </summary>
class Element {
public:
    virtual ~Element() = default; // 虚析构函数，避免多态内存泄漏
    virtual void Accept(Visitor* visitor) = 0; // 接受访问者的纯虚方法
};

/// <summary>
/// 具体元素A：存储基础数值数据
/// </summary>
class ConcreteElementA : public Element {
public:
    int data = 10; // 元素核心数据
    // 接受访问者，委托执行对应操作
    void Accept(Visitor* visitor) override {
        visitor->VisitConcreteElementA(this);
    }
};

/// <summary>
/// 具体元素B：存储运算数值数据
/// </summary>
class ConcreteElementB : public Element {
public:
    int value = 5; // 元素核心数据
    // 接受访问者，委托执行对应操作
    void Accept(Visitor* visitor) override {
        visitor->VisitConcreteElementB(this);
    }
};

// 实现具体访问者1的访问方法
void ConcreteVisitor1::VisitConcreteElementA(ConcreteElementA* element) {
    cout << "【ConcreteVisitor1】处理 ConcreteElementA，原始数据：" << element->data << endl;
}

void ConcreteVisitor1::VisitConcreteElementB(ConcreteElementB* element) {
    cout << "【ConcreteVisitor1】处理 ConcreteElementB，原始数据：" << element->value << endl;
}

// 实现具体访问者2的访问方法
void ConcreteVisitor2::VisitConcreteElementA(ConcreteElementA* element) {
    int result = element->data * 2;
    cout << "【ConcreteVisitor2】处理 ConcreteElementA，数据翻倍结果：" << result << endl;
}

void ConcreteVisitor2::VisitConcreteElementB(ConcreteElementB* element) {
    int result = element->value * element->value;
    cout << "【ConcreteVisitor2】处理 ConcreteElementB，数据平方结果：" << result << endl;
}

/// <summary>
/// 对象结构：管理元素集合，提供批量访问入口，负责内存释放
/// </summary>
class ObjectStructure {
private:
    vector<Element*> elements; // 存储元素指针的容器
public:
    ~ObjectStructure() {
        // 释放所有元素内存，避免泄漏
        for (auto elem : elements) {
            delete elem;
            elem = nullptr;
        }
    }

    // 添加元素到集合
    void AddElement(Element* element) {
        if (element == nullptr) {
            cout << "警告：添加的元素不可为nullptr" << endl;
            return;
        }
        elements.push_back(element);
    }

    // 接受访问者，遍历所有元素执行操作
    void Accept(Visitor* visitor) {
        if (visitor == nullptr) {
            cout << "警告：访问者不可为nullptr" << endl;
            return;
        }
        for (auto elem : elements) {
            elem->Accept(visitor);
        }
    }
};

// 客户端测试
int main() {
    try {
        // 1. 创建对象结构并添加元素
        ObjectStructure* structure = new ObjectStructure();
        structure->AddElement(new ConcreteElementA());
        structure->AddElement(new ConcreteElementB());

        // 2. 执行基础数据查看操作
        Visitor* visitor1 = new ConcreteVisitor1();
        cout << "=== 执行基础数据查看操作 ===" << endl;
        structure->Accept(visitor1);

        // 3. 执行数据运算处理操作
        Visitor* visitor2 = new ConcreteVisitor2();
        cout << "\n=== 执行数据运算处理操作 ===" << endl;
        structure->Accept(visitor2);

        // 释放访问者内存
        delete visitor1;
        delete visitor2;
        visitor1 = nullptr;
        visitor2 = nullptr;

        // 释放对象结构内存（内部会释放元素内存）
        delete structure;
        structure = nullptr;
    } catch (const exception& e) {
        cout << "执行异常：" << e.what() << endl;
    }
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C无面向对象特性，通过“结构体封装数据+函数指针封装行为”模拟访问者模式的核心逻辑。结构体封装元素与访问者的属性，函数指针模拟抽象方法，底层可控性强、无额外依赖，适用于嵌入式、底层开发等资源受限场景，完整还原模式“数据与操作分离”的核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 前向声明：解决结构体与函数指针的交叉引用问题
typedef struct ConcreteElementA ConcreteElementA;
typedef struct ConcreteElementB ConcreteElementB;
typedef struct Visitor Visitor;
typedef struct Element Element;

// 定义访问者函数指针类型（模拟抽象方法）
// 访问具体元素A的函数指针
typedef void (*VisitConcreteElementAFunc)(Visitor* visitor, ConcreteElementA* element);
// 访问具体元素B的函数指针
typedef void (*VisitConcreteElementBFunc)(Visitor* visitor, ConcreteElementB* element);

/// <summary>
/// 抽象访问者结构体：模拟访问者接口，封装函数指针
/// </summary>
typedef struct Visitor {
    VisitConcreteElementAFunc visit_concrete_element_a; // 访问元素A的方法
    VisitConcreteElementBFunc visit_concrete_element_b; // 访问元素B的方法
    char name[20]; // 访问者名称（用于日志输出）
} Visitor;

/// <summary>
/// 具体元素A：存储基础数值数据，封装accept方法
/// </summary>
typedef struct ConcreteElementA {
    int data; // 元素核心数据
    // accept方法：接受访问者访问
    void (*accept)(ConcreteElementA* element, Visitor* visitor);
} ConcreteElementA;

/// <summary>
/// 具体元素B：存储运算数值数据，封装accept方法
/// </summary>
typedef struct ConcreteElementB {
    int value; // 元素核心数据
    // accept方法：接受访问者访问
    void (*accept)(ConcreteElementB* element, Visitor* visitor);
} ConcreteElementB;

/// <summary>
/// 通用元素结构体：用于对象结构存储，统一管理不同类型元素
/// </summary>
typedef struct Element {
    enum { ELEMENT_A, ELEMENT_B } type; // 元素类型标识
    void* data; // 指向具体元素的指针
    // 通用accept方法：适配不同类型元素
    void (*accept)(void* element, Visitor* visitor);
} Element;

// -------------------------- 具体访问者1的实现 --------------------------
/// <summary>
/// 具体访问者1（基础数据查看）：访问元素A
/// </summary>
void concrete_visitor1_visit_a(Visitor* visitor, ConcreteElementA* element) {
    if (visitor == NULL || element == NULL) return;
    printf("【%s】处理 ConcreteElementA，原始数据：%d\n", visitor->name, element->data);
}

/// <summary>
/// 具体访问者1（基础数据查看）：访问元素B
/// </summary>
void concrete_visitor1_visit_b(Visitor* visitor, ConcreteElementB* element) {
    if (visitor == NULL || element == NULL) return;
    printf("【%s】处理 ConcreteElementB，原始数据：%d\n", visitor->name, element->value);
}

// -------------------------- 具体访问者2的实现 --------------------------
/// <summary>
/// 具体访问者2（数据运算处理）：访问元素A，数据翻倍
/// </summary>
void concrete_visitor2_visit_a(Visitor* visitor, ConcreteElementA* element) {
    if (visitor == NULL || element == NULL) return;
    int result = element->data * 2;
    printf("【%s】处理 ConcreteElementA，数据翻倍结果：%d\n", visitor->name, result);
}

/// <summary>
/// 具体访问者2（数据运算处理）：访问元素B，数据平方
/// </summary>
void concrete_visitor2_visit_b(Visitor* visitor, ConcreteElementB* element) {
    if (visitor == NULL || element == NULL) return;
    int result = element->value * element->value;
    printf("【%s】处理 ConcreteElementB，数据平方结果：%d\n", visitor->name, result);
}

// -------------------------- 具体元素的accept方法实现 --------------------------
/// <summary>
/// 元素A的accept方法：委托访问者执行对应操作
/// </summary>
void concrete_element_a_accept(ConcreteElementA* element, Visitor* visitor) {
    if (element == NULL || visitor == NULL) return;
    visitor->visit_concrete_element_a(visitor, element);
}

/// <summary>
/// 元素B的accept方法：委托访问者执行对应操作
/// </summary>
void concrete_element_b_accept(ConcreteElementB* element, Visitor* visitor) {
    if (element == NULL || visitor == NULL) return;
    visitor->visit_concrete_element_b(visitor, element);
}

/// <summary>
/// 通用元素的accept方法：根据元素类型，调用对应具体元素的accept方法
/// </summary>
void element_accept(void* elem, Visitor* visitor) {
    if (elem == NULL || visitor == NULL) return;
    Element* element = (Element*)elem;
    if (element->type == ELEMENT_A) {
        ConcreteElementA* a = (ConcreteElementA*)element->data;
        a->accept(a, visitor);
    } else if (element->type == ELEMENT_B) {
        ConcreteElementB* b = (ConcreteElementB*)element->data;
        b->accept(b, visitor);
    }
}

// -------------------------- 对象结构实现 --------------------------
/// <summary>
/// 对象结构：管理元素集合，提供批量访问入口，负责资源释放
/// </summary>
typedef struct ObjectStructure {
    Element** elements; // 存储通用元素指针的数组
    int count; // 当前元素数量
    int capacity; // 数组容量
} ObjectStructure;

/// <summary>
/// 初始化对象结构
/// </summary>
ObjectStructure* object_structure_init(int capacity) {
    if (capacity <= 0) return NULL;
    ObjectStructure* os = (ObjectStructure*)malloc(sizeof(ObjectStructure));
    if (os == NULL) return NULL;
    os->elements = (Element**)malloc(sizeof(Element*) * capacity);
    if (os->elements == NULL) {
        free(os);
        return NULL;
    }
    os->count = 0;
    os->capacity = capacity;
    return os;
}

/// <summary>
/// 向对象结构添加元素
/// </summary>
void object_structure_add(ObjectStructure* os, Element* element) {
    if (os == NULL || element == NULL || os->count >= os->capacity) return;
    os->elements[os->count++] = element;
}

/// <summary>
/// 接受访问者，遍历所有元素执行操作
/// </summary>
void object_structure_accept(ObjectStructure* os, Visitor* visitor) {
    if (os == NULL || visitor == NULL) return;
    for (int i = 0; i < os->count; i++) {
        os->elements[i]->accept(os->elements[i], visitor);
    }
}

/// <summary>
/// 释放对象结构及内部资源
/// </summary>
void object_structure_free(ObjectStructure* os) {
    if (os == NULL) return;
    // 释放每个元素的具体数据和通用元素结构体
    for (int i = 0; i < os->count; i++) {
        free(os->elements[i]->data);
        free(os->elements[i]);
    }
    free(os->elements);
    free(os);
}

// 客户端测试
int main() {
    // 1. 初始化具体访问者1（基础数据查看）
    Visitor visitor1 = {
        .visit_concrete_element_a = concrete_visitor1_visit_a,
        .visit_concrete_element_b = concrete_visitor1_visit_b,
        .name = "ConcreteVisitor1"
    };

    // 2. 初始化具体访问者2（数据运算处理）
    Visitor visitor2 = {
        .visit_concrete_element_a = concrete_visitor2_visit_a,
        .visit_concrete_element_b = concrete_visitor2_visit_b,
        .name = "ConcreteVisitor2"
    };

    // 3. 初始化具体元素A
    ConcreteElementA* elemA = (ConcreteElementA*)malloc(sizeof(ConcreteElementA));
    if (elemA == NULL) return -1;
    elemA->data = 10;
    elemA->accept = concrete_element_a_accept;
    // 包装为通用元素
    Element* elementA = (Element*)malloc(sizeof(Element));
    if (elementA == NULL) {
        free(elemA);
        return -1;
    }
    elementA->type = ELEMENT_A;
    elementA->data = elemA;
    elementA->accept = element_accept;

    // 4. 初始化具体元素B
    ConcreteElementB* elemB = (ConcreteElementB*)malloc(sizeof(ConcreteElementB));
    if (elemB == NULL) {
        free(elementA);
        free(elemA);
        return -1;
    }
    elemB->value = 5;
    elemB->accept = concrete_element_b_accept;
    // 包装为通用元素
    Element* elementB = (Element*)malloc(sizeof(Element));
    if (elementB == NULL) {
        free(elemB);
        free(elementA);
        free(elemA);
        return -1;
    }
    elementB->type = ELEMENT_B;
    elementB->data = elemB;
    elementB->accept = element_accept;

    // 5. 初始化对象结构并添加元素
    ObjectStructure* structure = object_structure_init(2);
    if (structure == NULL) {
        free(elementB);
        free(elemB);
        free(elementA);
        free(elemA);
        return -1;
    }
    object_structure_add(structure, elementA);
    object_structure_add(structure, elementB);

    // 6. 执行访问操作
    printf("=== 执行基础数据查看操作 ===\n");
    object_structure_accept(structure, &visitor1);

    printf("\n=== 执行数据运算处理操作 ===\n");
    object_structure_accept(structure, &visitor2);

    // 7. 释放所有资源
    object_structure_free(structure);
    return 0;
}

三、访问者模式的优缺点

访问者模式的核心价值是实现“数据与操作的解耦”，其优势集中在操作的灵活扩展，而局限则体现在元素扩展的困难性。实际开发中需结合业务场景权衡使用，平衡设计优雅与工程落地成本，避免过度设计。

3.1 核心优点

  • 操作扩展灵活，符合开闭原则：新增操作只需新增具体访问者，无需修改现有元素代码，大幅降低扩展成本。例如，新增“数据格式化”操作，仅需实现一个新的具体访问者，无需改动元素和对象结构。

  • 操作逻辑集中，便于维护复用：同一类操作逻辑集中在一个具体访问者中，避免操作逻辑分散在多个元素中，提升代码可读性和可维护性，同时便于同类操作的复用。

  • 分离数据与操作，降低耦合：数据结构（元素）专注于数据存储，操作逻辑（访问者）独立管理，打破数据与操作的强关联，让代码结构更清晰，符合“单一职责原则”。

  • 支持多态遍历，简化复杂处理：通过访问者可实现对不同类型元素的差异化处理，无需在客户端编写大量条件判断，简化复杂集合的遍历与处理逻辑。

3.2 主要缺点

  • 元素扩展困难，违反开闭原则：新增具体元素时，需修改所有抽象访问者和具体访问者的代码，添加对应的访问方法，大幅增加扩展成本，不适用于元素频繁变化的场景。

  • 破坏元素封装性：访问者需要访问元素的内部数据（如私有属性）才能执行操作，可能暴露元素的实现细节，破坏面向对象的封装性。

  • 代码复杂度提升，理解成本高：模式引入五大角色，且元素与访问者之间存在双向依赖，增加代码的复杂度和理解难度，不利于新手维护。

  • 面向过程语言适配性差：纯C等面向过程语言需通过复杂的结构体和函数指针模拟面向对象特性，实现代码繁琐、可读性低，增加开发和调试成本。

四、访问者模式的使用场景

访问者模式的适用场景具有明确的前提：数据结构稳定，操作频繁变化。以下结合具体业务场景与实战案例，帮助开发者精准判断适用性，避免滥用。

4.1 核心适用场景

  • 数据结构稳定，操作易变的场景：最典型的场景是编译器的语法树（AST），语法树结构固定，但需支持类型检查、代码生成、语法优化、错误检测等多种操作，新增操作只需新增访问者。

  • 跨元素的统一操作场景：对不同类型的对象执行统一的批量操作，如对文本、图片、视频等不同类型文件，执行备份、压缩、加密等操作，每种操作对应一个访问者。

  • 复杂集合的遍历与差异化处理场景：如电商系统中，对订单、商品、用户等不同实体，执行数据统计、报表生成、权限校验等操作，通过访问者实现差异化处理。

  • 框架/库的扩展场景：如ORM框架中，对不同数据库（MySQL、PostgreSQL、Oracle）执行增删改查操作，每种数据库的操作逻辑封装为一个访问者，便于扩展新数据库。

4.2 不适用场景

  • 元素类型频繁变化的场景（如频繁新增、删除元素），会导致访问者代码频繁修改，违反开闭原则。

  • 元素封装性要求极高的场景，访问者需要访问元素内部数据，会破坏封装。

  • 简单操作场景（仅需1-2种操作），使用访问者模式会增加代码复杂度，直接调用方法更高效。

五、总结

访问者模式的核心价值在于分离数据结构与数据操作，其设计初衷是解决“数据结构稳定但操作易变”的问题，通过引入访问者角色，实现操作的灵活扩展，同时让数据结构专注于自身职责。不同语言对该模式的实现方式差异显著，但核心思想一致：

面向对象语言（C#、Python、Golang、C++）可通过接口/抽象类直接适配，依托多态特性实现操作的动态分发，代码结构清晰、可维护性高；纯C语言则需通过结构体+函数指针模拟面向对象特性，虽实现繁琐，但能在资源受限场景中还原模式核心逻辑。

使用访问者模式时，需明确核心前提：数据结构是否稳定、操作是否频繁变化。若元素类型频繁变化，应避免使用；若操作逻辑频繁扩展，访问者模式能显著降低代码耦合，提升扩展能力。在实际开发中，需摒弃“为了使用设计模式而使用”的思维，结合业务场景合理选择，在设计优雅与代码可读性、可维护性之间找到平衡，让设计模式真正服务于工程实践。

发表于 更新于 分类于 ，

责任链模式

责任链模式（Chain of Responsibility Pattern）是行为型设计模式的经典范式，核心是解耦请求发送者与接收者，通过将多个处理对象串联为有序链路，使请求沿链路逐层传递，直至被适配的处理对象处理。该模式赋予每个处理对象自主决策能力，可选择处理请求或转发至下一级，无需硬编码请求与处理者的关联，显著提升代码灵活性、可扩展性与可维护性，是应对复杂请求处理场景的优选方案。本文从核心结构、多语言落地、优缺点剖析、适用场景及实战总结等维度，系统梳理责任链模式的设计思路与工程实践，为开发者提供可落地的技术参考。

一、责任链模式核心结构

责任链模式的核心的是拆分请求处理职责，实现请求有序流转与按需处理。通过明确三类核心角色的职责边界，确保请求规范传递、高效处理，各角色协同构成完整处理链路，具体定义如下：

1.1 抽象处理者（Handler）

抽象处理者是请求处理的统一契约，面向对象语言中通常以抽象类实现，无面向对象特性的语言（如纯C）则通过“结构体+函数指针”模拟。核心职责有二：一是声明处理请求的抽象方法，界定具体处理者的实现标准，保障接口一致性；二是维护下一个处理者的引用，为请求链式传递提供支撑，是链路串联的核心纽带。

1.2 具体处理者（ConcreteHandler）

具体处理者是抽象处理者的具象化实现，是请求处理的核心执行单元。它严格遵循抽象契约，实现具体处理逻辑：首先校验自身是否具备处理当前请求的权限（如金额范围、请求类型等）；若具备则执行处理并终止传递，若不具备则转发至下一级处理者；若到达链路末端仍无法处理，则执行兜底逻辑（拒绝请求、记录日志等），避免请求丢失。

1.3 客户端（Client）

客户端核心职责是构建责任链（串联具体处理者），并将请求发送至链路起点。客户端无需关注请求处理流程、处理者数量及传递路径，仅与链路入口交互即可发起请求，真正实现“请求发送”与“请求处理”的完全解耦，契合“迪米特法则”与“单一职责原则”。

核心流转逻辑：客户端创建并串联处理者→向链路起点发送请求→当前处理者校验权限→具备权限则处理并终止；无权限则转发→重复流程，直至请求被处理或链尾兜底。

核心逻辑示意图（以企业费用审批为例）：

1
2
3
4
5
客户端 → 小组长（≤1000元）→ 部门经理（≤5000元）→ 总监（≤10000元）→ 链尾（拒绝）
                │                │                │                │
                ├─ 处理（≤1000）  ├─ 处理（1001-5000）├─ 处理（5001-10000）├─ 兜底（>10000）
                └─ 转发（>1000）  └─ 转发（>5000）   └─ 转发（>10000）    └─ 终止传递

二、多语言实现责任链模式

以“企业费用审批”为统一实战场景（贴合真实业务，便于落地），设计三级审批链路：小组长处理≤1000元，部门经理处理≤5000元，总监处理≤10000元，超出则拒绝。以下提供C#、Python、Golang、C++及纯C的可运行实现，均贴合各语言原生特性，补充规范注释与边界校验，兼顾实用性与严谨性，清晰呈现模式适配思路。

2.1 C# 实现（面向对象规范实现）

C#作为强类型面向对象语言，通过抽象类定义抽象处理者，封装下一级处理者引用与设置方法，子类继承并实现审批逻辑，依托多态实现链式传递。代码结构清晰、可维护性高，适用于企业级业务系统，尤其适配复杂审批、拦截器链等场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
using System;

/// <summary>
/// 抽象处理者：定义审批者统一契约，规范审批行为
/// </summary>
public abstract class Approver
{
    /// <summary>下一个审批者，用于请求转发</summary>
    protected Approver _nextApprover;

    /// <summary>设置下一个审批者，构建责任链</summary>
    /// <param name="nextApprover">符合Approver契约的审批者对象</param>
    public void SetNext(Approver nextApprover)
    {
        _nextApprover = nextApprover;
    }

    /// <summary>抽象审批方法：子类必须实现具体逻辑</summary>
    /// <param name="amount">申请费用（非负整数）</param>
    public abstract void Approve(int amount);
}

/// <summary>具体处理者1：小组长（≤1000元）</summary>
public class GroupLeader : Approver
{
    public override void Approve(int amount)
    {
        if (amount < 0)
        {
            Console.WriteLine("错误：申请金额不能为负数，请核对后重新提交！");
            return;
        }

        if (amount <= 1000)
        {
            Console.WriteLine($"【小组长审批】{amount}元（≤1000元），审批通过。");
        }
        else if (_nextApprover != null)
        {
            Console.WriteLine($"【小组长审批】{amount}元超出权限（≤1000元），转发至部门经理。");
            _nextApprover.Approve(amount);
        }
        else
        {
            Console.WriteLine($"【小组长审批】{amount}元超出权限，无后续审批者，拒绝。");
        }
    }
}

/// <summary>具体处理者2：部门经理（≤5000元）</summary>
public class DepartmentManager : Approver
{
    public override void Approve(int amount)
    {
        if (amount < 0)
        {
            Console.WriteLine("错误：申请金额不能为负数，请核对后重新提交！");
            return;
        }

        if (amount <= 5000)
        {
            Console.WriteLine($"【部门经理审批】{amount}元（≤5000元），审批通过。");
        }
        else if (_nextApprover != null)
        {
            Console.WriteLine($"【部门经理审批】{amount}元超出权限（≤5000元），转发至总监。");
            _nextApprover.Approve(amount);
        }
        else
        {
            Console.WriteLine($"【部门经理审批】{amount}元超出权限，无后续审批者，拒绝。");
        }
    }
}

/// <summary>具体处理者3：总监（≤10000元）</summary>
public class Director : Approver
{
    public override void Approve(int amount)
    {
        if (amount < 0)
        {
            Console.WriteLine("错误：申请金额不能为负数，请核对后重新提交！");
            return;
        }

        if (amount <= 10000)
        {
            Console.WriteLine($"【总监审批】{amount}元（≤10000元），审批通过。");
        }
        else if (_nextApprover != null)
        {
            Console.WriteLine($"【总监审批】{amount}元超出权限（≤10000元），转发至下一级。");
            _nextApprover.Approve(amount);
        }
        else
        {
            Console.WriteLine($"【总监审批】{amount}元超出最高权限，拒绝。");
        }
    }
}

// 客户端：构建链路并测试
class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 创建审批者并串联链路
            Approver groupLeader = new GroupLeader();
            Approver deptManager = new DepartmentManager();
            Approver director = new Director();
            groupLeader.SetNext(deptManager);
            deptManager.SetNext(director);

            // 测试不同场景
            Console.WriteLine("=== 测试1：800元小额申请 ===");
            groupLeader.Approve(800);

            Console.WriteLine("\n=== 测试2：3000元中额申请 ===");
            groupLeader.Approve(3000);

            Console.WriteLine("\n=== 测试3：8000元大额申请 ===");
            groupLeader.Approve(8000);

            Console.WriteLine("\n=== 测试4：15000元超额申请 ===");
            groupLeader.Approve(15000);

            Console.WriteLine("\n=== 测试5：负数无效申请 ===");
            groupLeader.Approve(-500);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"审批异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（动态语言简洁实现）

Python遵循“鸭子类型”，无需显式定义接口，通过抽象基类（ABC）约定处理者行为，语法简洁、无冗余类型声明。依托动态特性，可灵活调整链路结构，适用于快速开发、轻量级项目，同时通过异常处理与边界校验保障健壮性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
from abc import ABC, abstractmethod

class Approver(ABC):
    """抽象处理者：定义审批统一接口"""
    def __init__(self):
        self.next_approver = None  # 下一级审批者

    def set_next(self, approver) -> None:
        """设置下一级审批者，校验接口一致性"""
        if not isinstance(approver, Approver):
            raise TypeError("下一级审批者必须是Approver子类实例")
        self.next_approver = approver

    @abstractmethod
    def approve(self, amount: int) -> None:
        """抽象审批方法，子类必须实现"""
        pass

class GroupLeader(Approver):
    """具体处理者1：小组长（≤1000元）"""
    def approve(self, amount: int) -> None:
        if amount < 0:
            print("错误：申请金额不能为负数，请核对后重新提交！")
            return

        if amount <= 1000:
            print(f"【小组长审批】{amount}元（≤1000元），审批通过。")
        elif self.next_approver:
            print(f"【小组长审批】{amount}元超出权限，转发至部门经理。")
            self.next_approver.approve(amount)
        else:
            print(f"【小组长审批】{amount}元超出权限，无后续审批者，拒绝。")

class DepartmentManager(Approver):
    """具体处理者2：部门经理（≤5000元）"""
    def approve(self, amount: int) -> None:
        if amount < 0:
            print("错误：申请金额不能为负数，请核对后重新提交！")
            return

        if amount <= 5000:
            print(f"【部门经理审批】{amount}元（≤5000元），审批通过。")
        elif self.next_approver:
            print(f"【部门经理审批】{amount}元超出权限，转发至总监。")
            self.next_approver.approve(amount)
        else:
            print(f"【部门经理审批】{amount}元超出权限，无后续审批者，拒绝。")

class Director(Approver):
    """具体处理者3：总监（≤10000元）"""
    def approve(self, amount: int) -> None:
        if amount < 0:
            print("错误：申请金额不能为负数，请核对后重新提交！")
            return

        if amount <= 10000:
            print(f"【总监审批】{amount}元（≤10000元），审批通过。")
        elif self.next_approver:
            print(f"【总监审批】{amount}元超出权限，转发至下一级。")
            self.next_approver.approve(amount)
        else:
            print(f"【总监审批】{amount}元超出最高权限，拒绝。")

# 客户端测试
if __name__ == "__main__":
    try:
        # 构建链路
        group_leader = GroupLeader()
        dept_manager = DepartmentManager()
        director = Director()
        group_leader.set_next(dept_manager)
        dept_manager.set_next(director)

        # 测试场景
        print("=== 测试1：800元小额申请 ===")
        group_leader.approve(800)

        print("\n=== 测试2：3000元中额申请 ===")
        group_leader.approve(3000)

        print("\n=== 测试3：8000元大额申请 ===")
        group_leader.approve(8000)

        print("\n=== 测试4：15000元超额申请 ===")
        group_leader.approve(15000)

        print("\n=== 测试5：负数无效申请 ===")
        group_leader.approve(-500)
    except Exception as e:
        print(f"审批异常：{str(e)}")

2.3 Golang 实现（接口至上轻量实现）

Go语言无类和继承，遵循“组合优于继承”原则，通过接口定义抽象处理者契约，结构体组合基础处理者（封装下一级引用）实现具体逻辑。依托接口隐式实现特性，代码极简高效，贴合Go语言设计理念，适配高并发后端场景（如API网关拦截链、审批服务）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package main

import "fmt"

// Approver 抽象处理者接口：定义审批方法签名
type Approver interface {
    Next(approver Approver) // 设置下一级审批者
 Approve(amount int)        // 处理审批请求
}

// BaseApprover 基础处理者：封装下一级引用，复用SetNext方法
type BaseApprover struct {
   xt Approver
}

// SetNext 实现链路串联逻辑，复用避免冗余
func (b *BaseApprover) SetNext(approver Approver) {
    approver == nil {
        intln("警告：下一级审批者不可为nil，避免链路断裂")
  return
        xt = approver
}

// GroupLeader 具体处理者1：小组长（≤1000元）
type GroupLeader struct {
  aseApprover // 组合基础处理者，复用SetNext
}

// Approve 实现小组长审批逻辑
func (g *GroupLeader) Approve(amount int) {
    amount < 0 {
         ntln("错误：申请金额不能为负数，请核对后重新提交！")
  return
  

    amount <= 1000 {
   mt.Printf("【小组长审批】%d元（≤1000元），审批通过。\n", amount)
 } else if g.next != nil {
    t.Printf("【小组长审批】%d元超出权限，转发至部门经理。\n", amount)
   .next.Approve(amount)
 } else {
    t.Printf("【小组长审批】%d元超出权限，无后续审批者，拒绝。\n", amount)
 }
}

// DepartmentManager 具体处理者2：部门经理（≤5000元）
type DepartmentManager struct {
        Baver
}

// Approve 实现部门经理审批逻辑
func (d *DepartmentManager) Approve(amount int) {
    amount < 0 {
   mt.Println("错误：申请金额不能为负数，请核对后重新提交！")
    turn
   
 if amount <= 5000 {
      Printf("【部门经理审批】%d元（≤5000元），审批通过。\n", amount)
   else if d.next != nil {
     .Printf("【部门经理审批】%d元超出权限，转发至总监。\n", amount)
     ext.Approve(amount)
 } else {
       rintf("【部门经理审批】%d元超出权限，无后续审批者，拒绝。\n", amount)
   }

// Director 具体处理者3：总监（≤10000元）
type Director struct {
   seApprover
}

// Approve 实现总监审批逻辑
func (dr *Director) Approve(amount int) {
        if amount         fmt.Pr错误：申请金额不能为负数，请核对后重新提交！")
  return
        }

unt <= 10000 {
   mt.Printf("【总监审批】%d元（≤10000元），审批通过。\n", amount)
    lse if dr.next != nil {
      Printf("【总监审批】%d元超出权限，转发至下一级。\n", amount)
      ext.Approve(amount)
   else {
  fmt.Printf("【总监审批】%d元超出最高权限，拒绝。\n", amount)
 }
}

// 客户端测试
func main() {
    创建审批者并构建链路
        grer := &GroupLeader{}
   ptManager := &DepartmentManager{}
        directDirector{}
   oupLeader.SetNext(deptManager)
  eptManager.SetNext(director)

 // 测试场景
   t.Println("=== 测试1：800元小额申请 ===")
  roupLeader.Approve(800)

        ntln("\n=== 测试2：3000元中额申请 ===")
   oupLeader.Approve(3000)

  mt.Println("\n=== 测试3：8000元大额申请 ===")
  roupLeader.Approve(8000)

    .Println("\n=== 测试4：15000元超额申请 ===")
   oupLeader.Approve(15000)

    .Println("\n=== 测试5：负数无效申请 ===")
   oupLeader.Approve(-500)
}
           gr    fmt     gr    fmt      g      f     grfmt.Pri      g     fm             d     gror := &     deoupLead    //                           }           dr.n          fmt.    } e             f        if amo              intln("< 0 {
             Ba     }
         fmt.P                  d.n           fmt     }    fmt.                   }
     re                    f     ifseAppro                   fm             g                   fm                    f     if      }                     fmt.Pri     if      B}
        b.ne                      fmt.Pr    if      ne           Set

2.4 C++ 实现（抽象类+多态经典实现）

C++通过抽象类（纯虚函数）定义抽象处理者接口，子类继承并实现具体逻辑，依托多态实现链式传递，是责任链模式的经典实现。需手动管理内存（虚析构函数避免泄漏），兼顾灵活性与高性能，适用于底层开发、高频调用场景（如嵌入式请求处理链）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include <iostream>
using namespace std;

// 抽象处理者：纯虚函数定义审批接口
class Approver {
protected:
    Approver* nextApprover; // 下一级审批者指针
public:
    Approver() : nextApprover(nullptr) {}
    virtual ~Approver() {} // 虚析构函数，避免多态内存泄漏

    /// <summary>设置下一级审批者</summary>
    void setNext(Approver* approver) {
        nextApprover = approver;
    }

    /// <summary>抽象审批方法，子类必须实现</summary>
    virtual void approve(int amount) = 0;
};

// 具体处理者1：小组长（≤1000元）
class GroupLeader : public Approver {
public:
    void approve(int amount) override {
        if (amount < 0) {
            cout << "错误：申请金额不能为负数，请核对后重新提交！" << endl;
            return;
        }

        if (amount <= 1000) {
            cout << "【小组长审批】" << amount << "元（≤1000元），审批通过。" << endl;
        } else if (nextApprover != nullptr) {
            cout << "【小组长审批】" << amount << "元超出权限，转发至部门经理。" << endl;
            nextApprover->approve(amount);
        } else {
            cout << "【小组长审批】" << amount << "元超出权限，无后续审批者，拒绝。" << endl;
        }
    }
};

// 具体处理者2：部门经理（≤5000元）
class DepartmentManager : public Approver {
public:
    void approve(int amount) override {
        if (amount < 0) {
            cout << "错误：申请金额不能为负数，请核对后重新提交！" << endl;
            return;
        }

        if (amount <= 5000) {
            cout << "【部门经理审批】" << amount << "元（≤5000元），审批通过。" << endl;
        } else if (nextApprover != nullptr) {
            cout << "【部门经理审批】" << amount << "元超出权限，转发至总监。" << endl;
            nextApprover->approve(amount);
        } else {
            cout << "【部门经理审批】" << amount << "元超出权限，无后续审批者，拒绝。" << endl;
        }
    }
};

// 具体处理者3：总监（≤10000元）
class Director : public Approver {
public:
    void approve(int amount) override {
        if (amount < 0) {
            cout << "错误：申请金额不能为负数，请核对后重新提交！" << endl;
            return;
        }

        if (amount <= 10000) {
            cout << "【总监审批】" << amount << "元（≤10000元），审批通过。" << endl;
        } else if (nextApprover != nullptr) {
            cout << "【总监审批】" << amount << "元超出权限，转发至下一级。" << endl;
            nextApprover->approve(amount);
        } else {
            cout << "【总监审批】" << amount << "元超出最高权限，拒绝。" << endl;
        }
    }
};

// 客户端测试
int main() {
    try {
        // 创建审批者并构建链路
        Approver* groupLeader = new GroupLeader();
        Approver* deptManager = new DepartmentManager();
        Approver* director = new Director();
        groupLeader->setNext(deptManager);
        deptManager->setNext(director);

        // 测试场景
        cout << "=== 测试1：800元小额申请 ===" << endl;
        groupLeader->approve(800);

        cout << "\n=== 测试2：3000元中额申请 ===" << endl;
        groupLeader->approve(3000);

        cout << "\n=== 测试3：8000元大额申请 ===" << endl;
        groupLeader->approve(8000);

        cout << "\n=== 测试4：15000元超额申请 ===" << endl;
        groupLeader->approve(15000);

        cout << "\n=== 测试5：负数无效申请 ===" << endl;
        groupLeader->approve(-500);

        // 释放内存，避免泄漏
        delete groupLeader;
        delete deptManager;
        delete director;
        groupLeader = nullptr;
        deptManager = nullptr;
        director = nullptr;
    } catch (const exception& e) {
        cout << "审批异常：" << e.what() << endl;
    }
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C无面向对象特性，通过“结构体封装数据+函数指针封装行为”模拟责任链核心逻辑。结构体封装处理者属性与方法指针，函数指针模拟抽象接口，底层可控性强，无额外依赖，适用于嵌入式、底层开发等资源受限场景，完整还原模式核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
#include <stdio.h>
#include <stdlib.h>

// 前向声明：解决结构体与函数指针交叉引用
typedef struct Approver Approver;

// 处理者结构体：模拟“属性+方法”
struct Approver {
    void (*set_next)(Approver* self, Approver* next); // 设置下一级
    void (*approve)(Approver* self, int amount);      // 审批逻辑
    Approver* next;                                   // 下一级指针
};

/// <summary>基础set_next方法，复用避免冗余</summary>
void base_set_next(Approver* self, Approver* next) {
    if (self == NULL) {
        fprintf(stderr, "警告：当前处理者不可为NULL\n");
        return;
    }
    self->next = next;
}

// 具体处理者1：小组长（≤1000元）
typedef struct {
    Approver base; // 组合基础处理者，模拟“继承”
} GroupLeader;

/// <summary>小组长审批逻辑</summary>
void group_leader_approve(Approver* self, int amount) {
    if (self == NULL) {
        fprintf(stderr, "错误：处理者不可为NULL\n");
        return;
    }

    if (amount < 0) {
        printf("错误：申请金额不能为负数，请核对后重新提交！\n");
        return;
    }

    if (amount <= 1000) {
        printf("【小组长审批】%d元（≤1000元），审批通过。\n", amount);
    } else if (self->next != NULL) {
        printf("【小组长审批】%d元超出权限，转发至部门经理。\n", amount);
        self->next->approve(self->next, amount);
    } else {
        printf("【小组长审批】%d元超出权限，无后续审批者，拒绝。\n", amount);
    }
}

/// <summary>初始化小组长，分配内存并绑定方法</summary>
GroupLeader* create_group_leader() {
    GroupLeader* gl = (GroupLeader*)malloc(sizeof(GroupLeader));
    if (gl == NULL) {
        fprintf(stderr, "错误：内存分配失败\n");
        return NULL;
    }
    gl->base.set_next = base_set_next;
    gl->base.approve = group_leader_approve;
    gl->base.next = NULL;
    return gl;
}

// 具体处理者2：部门经理（≤5000元）
typedef struct {
    Approver base;
} DepartmentManager;

/// <summary>部门经理审批逻辑</summary>
void dept_manager_approve(Approver* self, int amount) {
    if (self == NULL) {
        fprintf(stderr, "错误：处理者不可为NULL\n");
        return;
    }

    if (amount < 0) {
        printf("错误：申请金额不能为负数，请核对后重新提交！\n");
        return;
    }

    if (amount <= 5000) {
        printf("【部门经理审批】%d元（≤5000元），审批通过。\n", amount);
    } else if (self->next != NULL) {
        printf("【部门经理审批】%d元超出权限，转发至总监。\n", amount);
        self->next->approve(self->next, amount);
    } else {
        printf("【部门经理审批】%d元超出权限，无后续审批者，拒绝。\n", amount);
    }
}

/// <summary>初始化部门经理</summary>
DepartmentManager* create_dept_manager() {
    DepartmentManager* dm = (DepartmentManager*)malloc(sizeof(DepartmentManager));
    if (dm == NULL) {
        fprintf(stderr, "错误：内存分配失败\n");
        return NULL;
    }
    dm->base.set_next = base_set_next;
    dm->base.approve = dept_manager_approve;
    dm->base.next = NULL;
    return dm;
}

// 具体处理者3：总监（≤10000元）
typedef struct {
    Approver base;
} Director;

/// <summary>总监审批逻辑</summary>
void director_approve(Approver* self, int amount) {
    if (self == NULL) {
        fprintf(stderr, "错误：处理者不可为NULL\n");
        return;
    }

    if (amount < 0) {
        printf("错误：申请金额不能为负数，请核对后重新提交！\n");
        return;
    }

    if (amount <= 10000) {
        printf("【总监审批】%d元（≤10000元），审批通过。\n", amount);
    } else if (self->next != NULL) {
        printf("【总监审批】%d元超出权限，转发至下一级。\n", amount);
        self->next->approve(self->next, amount);
    } else {
        printf("【总监审批】%d元超出最高权限，拒绝。\n", amount);
    }
}

/// <summary>初始化总监</summary>
Director* create_director() {
    Director* dr = (Director*)malloc(sizeof(Director));
    if (dr == NULL) {
        fprintf(stderr, "错误：内存分配失败\n");
        return NULL;
    }
    dr->base.set_next = base_set_next;
    dr->base.approve = director_approve;
    dr->base.next = NULL;
    return dr;
}

// 客户端测试
int main() {
    // 创建审批者
    GroupLeader* groupLeader = create_group_leader();
    DepartmentManager* deptManager = create_dept_manager();
    Director* director = create_director();

    if (groupLeader == NULL || deptManager == NULL || director == NULL) {
        fprintf(stderr, "错误：审批者创建失败，程序退出\n");
        return -1;
    }

    // 构建链路
    groupLeader->base.set_next((Approver*)groupLeader, (Approver*)deptManager);
    deptManager->base.set_next((Approver*)deptManager, (Approver*)director);

    // 测试场景
    printf("=== 测试1：800元小额申请 ===\n");
    groupLeader->base.approve((Approver*)groupLeader, 800);

    printf("\n=== 测试2：3000元中额申请 ===\n");
    groupLeader->base.approve((Approver*)groupLeader, 3000);

    printf("\n=== 测试3：8000元大额申请 ===\n");
    groupLeader->base.approve((Approver*)groupLeader, 8000);

    printf("\n=== 测试4：15000元超额申请 ===\n");
    groupLeader->base.approve((Approver*)groupLeader, 15000);

    printf("\n=== 测试5：负数无效申请 ===\n");
    groupLeader->base.approve((Approver*)groupLeader, -500);

    // 释放内存
    free(groupLeader);
    free(deptManager);
    free(director);
    groupLeader = NULL;
    deptManager = NULL;
    director = NULL;

    return 0;
}

三、责任链模式的优缺点

责任链模式的核心价值的是解耦请求发送与处理，实现灵活扩展，但也存在性能与调试等方面的局限。实际开发中需结合链路长度、处理复杂度和性能要求权衡使用，平衡设计优雅与工程落地。

3.1 核心优点

  • 解耦请求传递，降低系统耦合：客户端仅需发送请求至链路起点，无需知晓处理者、顺序及逻辑，实现“发送”与“处理”完全解耦，契合“迪米特法则”，提升可维护性。

  • 灵活扩展，符合开闭原则：增删处理者仅需调整链路结构，无需修改原有代码。如新增审批级别时，仅需新增处理者并调整串联关系，降低扩展成本。

  • 动态调整链路，适配多场景：运行时可修改处理者顺序、增删节点，适配差异化需求。如普通员工与管理层审批链路不同，通过动态调整即可实现。

  • 职责单一，逻辑清晰：每个处理者仅负责自身权限内的请求，代码逻辑简洁，便于调试、测试与维护，降低迭代成本。

  • 简化客户端逻辑：避免客户端大量嵌套条件判断，仅需触发请求，减少冗余代码，提升可读性。

3.2 主要缺点

  • 请求兜底风险：若未设置链尾兜底处理者，请求可能遍历链路后无人处理，需额外设计兜底逻辑（如拒绝、日志），增加开发成本。

  • 性能损耗：链路过长会增加请求传递开销，高频场景下影响响应速度，需通过合并处理者、缩短链路优化。

  • 调试难度高：请求处理路径分散在多个处理者中，排查问题需逐一遍历链路，增加调试成本，可通过日志、链路追踪工具优化。

  • 简单场景过度设计：仅1-2个处理者、无扩展需求的场景，使用责任链会增加复杂度，直接调用处理者更高效。

  • 依赖管理复杂：处理者间存在依赖时，需额外引入上下文传递处理结果，增加实现复杂度。

四、责任链模式的使用场景

责任链模式适用于“请求需多个对象依次处理，且处理者可动态调整”的场景。以下结合具体场景与实战案例，帮助开发者精准判断适用性，避免滥用。

4.1 核心适用场景

  • 多级审批流程：企业费用、请假、订单、合同审批等，请求按级别传递，每个级别处理对应权限请求，是最典型的应用场景。

  • 过滤器/拦截器链：Web框架拦截器（Spring Interceptor、Gin中间件）、日志过滤器、数据校验过滤器，请求经多个环节依次处理，可动态增删。

  • 异常处理链：业务异常、系统异常、网络异常等分级处理，异常沿链路传递，直至找到匹配处理器，提升系统健壮性。

  • 事件分发机制：GUI组件事件传递、事件总线多级处理，请求沿链路按需处理。

  • API网关请求处理：限流、鉴权、日志、转发等环节按链路执行，可动态调整处理环节，适配不同服务需求。

4.2 典型实战案例

  • 企业费用审批系统：请求按“小组长→部门经理→总监→财务”传递，新增审批级别或调整权限时，仅修改链路结构，适配组织架构调整。

  • Web框架拦截器链：HTTP请求依次经过“跨域拦截→鉴权拦截→参数校验→日志记录→请求转发”，各环节独立，可灵活增删，提升系统扩展性。

五、总结

责任链模式通过“链式传递”将请求处理逻辑分散到独立处理者中，完美契合“开闭原则”与“单一职责原则”。无论是面向对象语言（C#、Python、Golang、C++）还是面向过程语言（纯C），均可通过各自特性实现核心逻辑——差异仅在实现形式（类/接口/结构体+函数指针），核心思想一致。

实际开发中，需根据场景合理取舍：复杂请求处理流程中，责任链可显著提升代码可维护性与扩展性；简单场景则需避免过度设计。合理运用责任链模式，能让代码结构更清晰、扩展更灵活，是构建高内聚、低耦合系统的重要工具。

发表于 更新于 分类于 ，

策略模式（Strategy Pattern）是一种经典的行为型设计模式，其核心思想是“封装变化、解耦算法”——将一组可替换的算法（策略）封装为独立的组件，使算法能够独立于使用它的客户端灵活切换，彻底摒弃代码中冗余的条件判断语句，大幅提升代码的可扩展性、可维护性与复用性。它不仅是“开闭原则”的典型实践，更是应对复杂业务场景中“算法动态切换”需求的最优解决方案之一。本文将从核心结构、多语言落地实现、优缺点剖析、适用场景及实战总结等维度，全面拆解策略模式的设计思路与工程实践。

一、策略模式核心结构

策略模式的设计核心是“解耦算法的定义与使用”，通过明确的角色分工，实现策略的灵活替换与独立扩展。其核心角色分为三类，各角色职责清晰、协同工作，构成完整的策略驱动体系，具体如下：

1.1 环境类（Context）

作为策略的“调度中心”与“客户端交互入口”，环境类维护一个抽象策略对象的引用，对外提供统一的调用接口，负责将客户端的请求委派给当前的具体策略执行。它不直接实现任何算法逻辑，也不关心具体策略的内部实现，仅负责策略的切换与调用，是连接客户端与策略的桥梁。

1.2 抽象策略类（Strategy）

定义所有具体策略的公共行为契约，通常以接口（面向对象语言）或函数指针（无面向对象特性语言）的形式存在。它声明了所有具体策略必须实现的核心方法（如算法执行方法），规范了策略的统一调用标准，确保环境类能通过统一接口调用不同的策略，实现“多策略统一适配”。

1.3 具体策略类（ConcreteStrategy）

抽象策略的具体实现，是算法逻辑的核心载体。它严格遵循抽象策略定义的接口，封装了某一种特定的算法逻辑，是策略模式的核心扩展点。新增算法时，只需新增对应的具体策略类，无需修改原有代码，完美契合“开闭原则”。

核心流转逻辑：客户端初始化环境类 → 环境类设置具体策略 → 客户端通过环境类调用策略方法 → 环境类委派请求给当前策略 → 具体策略执行算法逻辑 → 如需切换策略，客户端通过环境类更换具体策略，无需修改其他代码。

二、多语言实现策略模式

为适配不同技术栈开发者的落地需求，本文以“二元运算策略”为统一案例（通过加法、乘法两种可切换策略，直观呈现策略模式的核心逻辑），分别提供C#、Python、Golang、C++及纯C语言的可运行实现。各实现均贴合语言原生特性，补充规范注释、异常处理与边界校验，兼顾实用性与严谨性，清晰展现策略模式在不同语言中的适配思路与最佳实践。

2.1 C# 实现（面向对象规范实现）

C# 作为强类型面向对象语言，通过接口严格定义抽象策略契约，依托类的继承与多态实现具体策略逻辑，环境类通过属性封装策略引用，确保策略管理的安全性与规范性，适配企业级业务系统开发，尤其适合需要严格接口约束的场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
using System;

/// <summary>
/// 抽象策略接口：定义二元运算策略的统一契约
/// </summary>
public interface IStrategy
{
    /// <summary>
    /// 执行二元运算
    /// </summary>
    /// <param name="a">运算数A</param>
    /// <param name="b">运算数B</param>
    /// <returns>运算结果</returns>
    int Calculate(int a, int b);
}

/// <summary>
/// 具体策略1：加法策略
/// </summary>
public class AddStrategy : IStrategy
{
    public int Calculate(int a, int b)
    {
        return a + b;
    }
}

/// <summary>
/// 具体策略2：乘法策略
/// </summary>
public class MultiplyStrategy : IStrategy
{
    public int Calculate(int a, int b)
    {
        return a * b;
    }
}

/// <summary>
/// 环境类：管理策略引用，委派策略执行
/// </summary>
public class Context
{
    // 私有字段存储当前策略，避免外部直接修改
    private IStrategy _currentStrategy;

    /// <summary>
    /// 动态切换策略
    /// </summary>
    /// <param name="strategy">新的策略对象</param>
    /// <exception cref="ArgumentNullException">策略对象不可为null</exception>
    public void SetStrategy(IStrategy strategy)
    {
        _currentStrategy = strategy ?? throw new ArgumentNullException(nameof(strategy), "策略对象不可为null");
    }

    /// <summary>
    /// 执行当前策略的运算逻辑
    /// </summary>
    /// <param name="a">运算数A</param>
    /// <param name="b">运算数B</param>
    /// <returns>运算结果</returns>
    /// <exception cref="InvalidOperationException">未设置策略时抛出异常</exception>
    public int ExecuteStrategy(int a, int b)
    {
        if (_currentStrategy == null)
        {
            throw new InvalidOperationException("请先设置具体策略");
        }
        return _currentStrategy.Calculate(a, b);
    }
}

// 客户端调用示例
class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 初始化环境类
            Context context = new Context();

            // 切换为加法策略并执行
            context.SetStrategy(new AddStrategy());
            Console.WriteLine($"5 + 3 = {context.ExecuteStrategy(5, 3)}"); // 输出：5 + 3 = 8

            // 动态切换为乘法策略并执行
            context.SetStrategy(new MultiplyStrategy());
            Console.WriteLine($"5 × 3 = {context.ExecuteStrategy(5, 3)}"); // 输出：5 × 3 = 15
        }
        catch (Exception ex)
        {
            Console.WriteLine($"执行异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，可通过抽象基类（ABC）约定策略行为，语法简洁、无繁琐类型声明。依托动态类型特性，环境类可灵活切换策略对象，适配快速开发、脚本开发及轻量级项目，同时通过异常处理保证代码健壮性，完美保留策略模式的核心逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
from abc import ABC, abstractmethod

class Strategy(ABC):
    """抽象策略基类：约定二元运算的统一接口"""
    @abstractmethod
    def calculate(self, a: int, b: int) -> int:
        """
        执行二元运算
        :param a: 运算数A
        :param b: 运算数B
        :return: 运算结果
        """
        pass

class AddStrategy(Strategy):
    """具体策略1：加法策略"""
    def calculate(self, a: int, b: int) -> int:
        return a + b

class MultiplyStrategy(Strategy):
    """具体策略2：乘法策略"""
    def calculate(self, a: int, b: int) -> int:
        return a * b

class Context:
    """环境类：管理策略，委派策略执行"""
    def __init__(self):
        self._strategy = None  # 初始无策略

    def set_strategy(self, strategy: Strategy) -> None:
        """
        动态切换策略
        :param strategy: 具体策略对象
        :raises TypeError: 策略对象必须是Strategy的子类实例
        """
        if not isinstance(strategy, Strategy):
            raise TypeError("策略对象必须是Strategy的子类实例")
        self._strategy = strategy

    def execute_strategy(self, a: int, b: int) -> int:
        """
        执行当前策略的运算逻辑
        :param a: 运算数A
        :param b: 运算数B
        :return: 运算结果
        :raises ValueError: 未设置策略时抛出异常
        """
        if self._strategy is None:
            raise ValueError("请先通过set_strategy方法设置具体策略")
        return self._strategy.calculate(a, b)

# 客户端调用示例
if __name__ == "__main__":
    try:
        context = Context()
        
        # 切换为加法策略
        context.set_strategy(AddStrategy())
        print(f"5 + 3 = {context.execute_strategy(5, 3)}")  # 输出：5 + 3 = 8
        
        # 动态切换为乘法策略
        context.set_strategy(MultiplyStrategy())
        print(f"5 × 3 = {context.execute_strategy(5, 3)}")  # 输出：5 × 3 = 15
    except Exception as e:
        print(f"执行异常：{str(e)}")

2.3 Golang 实现（接口至上轻量实现）

Go 语言无类和继承，核心遵循“组合优于继承”原则，通过接口定义抽象策略契约，结构体实现具体策略逻辑，代码极简高效。依托接口的隐式实现特性，无需显式声明继承关系，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发后端开发场景，尤其适合对性能有一定要求的策略切换场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package main

import "fmt"

// Strategy 抽象策略接口：定义二元运算的统一方法签名
type Strategy interface {
  alculate(a, b int) int
}

// AddStrategy 具体策略1：加法策略
type AddStrategy struct{}

// Calculate 实现加法运算逻辑
func (s *AddStrategy) Calculate(a, b int) int {
  eturn a + b
}

// MultiplyStrategy 具体策略2：乘法策略
type MultiplyStrategy struct{}

// Calculate 实现乘法运算逻辑
func (s *MultiplyStrategy) Calculate(a, b int) int {
  eturn a * b
}

// Context 环境类：管理策略引用，委派策略执行
type Context struct {
      egy Strategy // 当前策略引用
}

// SetStrategy 动态切换策略
func (c *Context) SetStrategy(strategy Strategy) {
     trategy == nil {
    t.Println("警告：策略对象不可为nil")
      rn
        }
   y = strategy
}

// ExecuteStrategy 执行当前策略的运算逻辑
func (c *Context) ExecuteStrategy(a, b int) (int, error) {
    c.strategy == nil {
          , fmt.Errorf("请先设置具体策略")
  
        return c.strateglate(a, b), nil
}

// 客户端调用示例
func main() {
     始化环境类
 context := &Context{}

    切换为加法策略并执行
  ontext.SetStrategy(&AddStrategy{})
  esult, err := context.ExecuteStrategy(5, 3)
  f err != nil {
     .Printf("执行异常：%v\n", err)
   else {
                f 3 = %d\n", result) // 输出：5 + 3 = 8
        动态切换为乘法策略并执行
        context.Segy(&MultiplyStrategy{})
       , err = context.ExecuteStrategy(5, 3)
     rr != nil {
   mt.Printf("执行异常：%v\n", err)
        } elfmt.Printf("5 × 3 = %d\n", result) // 输出：5 × 3 = 15
        }  
}
    se {
                             f   if e resulttStrate    //     }

mt.Printf("5 +      }           fmt      i      r      c     //          // 初y.Calcu      }      return 0    if      c.strateg          retu            fm   if s  strat      r      r      C

2.4 C++ 实现（抽象类+多态经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象策略接口，子类继承并实现具体策略逻辑，依托多态特性实现策略的灵活切换。需手动管理内存（通过虚析构函数避免内存泄漏），兼顾灵活性与高性能，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#include <iostream>
using namespace std;

// 抽象策略类：纯虚函数定义二元运算接口
class Strategy {
public:
    virtual ~Strategy() = default; // 虚析构函数，避免多态场景内存泄漏
    /// <summary>
    /// 执行二元运算
    /// </summary>
    /// <param name="a">运算数A</param>
    /// <param name="b">运算数B</param>
    /// <returns>运算结果</returns>
    virtual int Calculate(int a, int b) = 0;
};

// 具体策略1：加法策略
class AddStrategy : public Strategy {
public:
    int Calculate(int a, int b) override {
        return a + b;
    }
};

// 具体策略2：乘法策略
class MultiplyStrategy : public Strategy {
public:
    int Calculate(int a, int b) override {
        return a * b;
    }
};

// 环境类：管理策略指针，委派策略执行
class Context {
private:
    Strategy* _currentStrategy; // 当前策略指针
public:
    // 构造函数：初始化策略指针为nullptr
    Context() : _currentStrategy(nullptr) {}

    // 析构函数：释放策略对象内存
    ~Context() {
        if (_currentStrategy != nullptr) {
            delete _currentStrategy;
            _currentStrategy = nullptr;
        }
    }

    /// <summary>
    /// 动态切换策略
    /// </summary>
    /// <param name="strategy">新的策略对象指针</param>
    void SetStrategy(Strategy* strategy) {
        // 释放旧策略内存
        if (_currentStrategy != nullptr) {
            delete _currentStrategy;
        }
        _currentStrategy = strategy;
    }

    /// <summary>
    /// 执行当前策略的运算逻辑
    /// </summary>
    /// <param name="a">运算数A</param>
    /// <param name="b">运算数B</param>
    /// <returns>运算结果</returns>
    /// <exception cref="runtime_error">未设置策略时抛出异常</exception>
    int ExecuteStrategy(int a, int b) {
        if (_currentStrategy == nullptr) {
            throw runtime_error("请先设置具体策略");
        }
        return _currentStrategy->Calculate(a, b);
    }
};

// 客户端调用示例
int main() {
    try {
        Context context;

        // 切换为加法策略并执行
        context.SetStrategy(new AddStrategy());
        cout << "5 + 3 = " << context.ExecuteStrategy(5, 3) << endl; // 输出：5 + 3 = 8

        // 动态切换为乘法策略并执行
        context.SetStrategy(new MultiplyStrategy());
        cout << "5 × 3 = " << context.ExecuteStrategy(5, 3) << endl; // 输出：5 × 3 = 15
    }
    catch (const exception& e) {
        cout << "执行异常：" << e.what() << endl;
    }
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为”，手动模拟策略模式的核心逻辑。用结构体封装环境类的属性（策略函数指针），用函数指针模拟抽象策略的接口方法，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“策略封装、动态切换”的核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <stdio.h>
#include <stdlib.h>

// 定义策略函数指针类型（模拟抽象策略接口）
// 参数：两个运算数a、b，返回值：运算结果
typedef int (*StrategyFunc)(int a, int b);

// 环境结构体：封装当前策略函数指针
typedef struct {
    StrategyFunc strategy; // 当前策略的函数指针
} Context;

/// <summary>
/// 初始化环境类
/// </summary>
/// <param name="context">环境结构体指针</param>
void Context_Init(Context* context) {
    if (context == NULL) {
        fprintf(stderr, "警告：环境对象不可为NULL\n");
        return;
    }
    context->strategy = NULL; // 初始无策略
}

/// <summary>
/// 动态切换策略
/// </summary>
/// <param name="context">环境结构体指针</param>
/// <param name="strategy">策略函数指针</param>
void Context_SetStrategy(Context* context, StrategyFunc strategy) {
    if (context == NULL) {
        fprintf(stderr, "警告：环境对象不可为NULL\n");
        return;
    }
    context->strategy = strategy;
}

/// <summary>
/// 执行当前策略的运算逻辑
/// </summary>
/// <param name="context">环境结构体指针</param>
/// <param name="a">运算数A</param>
/// <param name="b">运算数B</param>
/// <returns>运算结果（异常时返回-1）</returns>
int Context_ExecuteStrategy(Context* context, int a, int b) {
    if (context == NULL) {
        fprintf(stderr, "错误：环境对象不可为NULL\n");
        return -1;
    }
    if (context->strategy == NULL) {
        fprintf(stderr, "错误：请先设置具体策略\n");
        return -1;
    }
    // 调用当前策略的函数指针，执行运算
    return context->strategy(a, b);
}

// 具体策略1：加法策略函数
int AddStrategy(int a, int b) {
    return a + b;
}

// 具体策略2：乘法策略函数
int MultiplyStrategy(int a, int b) {
    return a * b;
}

// 客户端调用示例
int main() {
    Context context;
    // 初始化环境
    Context_Init(&context);

    // 切换为加法策略并执行
    Context_SetStrategy(&context, AddStrategy);
    int result = Context_ExecuteStrategy(&context, 5, 3);
    if (result != -1) {
        printf("5 + 3 = %d\n", result); // 输出：5 + 3 = 8
    }

    // 动态切换为乘法策略并执行
    Context_SetStrategy(&context, MultiplyStrategy);
    result = Context_ExecuteStrategy(&context, 5, 3);
    if (result != -1) {
        printf("5 × 3 = %d\n", result); // 输出：5 × 3 = 15
    }

    return 0;
}

三、策略模式的优缺点

策略模式的核心价值是“解耦算法与客户端，实现算法的灵活切换与独立扩展”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的策略数量、切换频率和性能要求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题。

3.1 核心优点

  • 解耦算法与使用方，提升可维护性：策略的实现与调用完全分离，客户端无需关注算法的内部细节，只需通过环境类调用策略。修改某一策略的逻辑时，无需改动客户端和其他策略代码，降低维护成本，也减少了代码耦合带来的风险。

  • 灵活扩展，符合开闭原则：新增策略时，只需实现抽象策略接口（或定义策略函数），无需修改原有代码，即可通过环境类切换使用新策略。例如支付系统新增“银联支付”策略，仅需新增UnionPayStrategy类，无需改动支付核心逻辑。

  • 消除冗余条件判断，提升代码可读性：彻底替代大量嵌套的if/else或switch语句，将分散的算法逻辑封装为独立策略，让代码结构更清晰，逻辑更易理解和调试。例如排序算法的选择，若用条件判断需区分冒泡、快排、归并等分支，而策略模式可将每种排序封装为独立策略，代码更简洁。

  • 策略复用性强，减少代码冗余：不同的客户端（或场景）可共享同一个策略对象，相同的算法逻辑无需重复编写。例如电商系统的“满减优惠”策略，可在PC端、移动端、小程序等多个场景中复用。

  • 便于单元测试：每个策略独立封装，可单独编写单元测试用例，无需依赖客户端和其他策略，提升测试效率和代码健壮性。

3.2 主要缺点

  • 类/结构体数量增加，存在“类爆炸”风险：每新增一个策略，就需要新增一个具体策略类（或策略函数），当策略数量较多时（如10个以上），会导致类/函数数量激增，增加代码量和维护成本。

  • 客户端需了解所有策略，增加使用成本：客户端必须清楚所有策略的差异和适用场景，才能选择合适的策略，这增加了客户端的使用复杂度。例如支付系统，客户端需知道支付宝、微信、银联等策略的区别，才能根据用户选择切换策略。

  • 轻微性能损耗：部分语言（如C++/C#）中，策略的切换可能涉及对象的创建与销毁，多态调用也会带来轻微的性能开销（可通过策略单例、对象池化等方式优化）。

  • 策略间无依赖管理：若策略之间存在依赖关系（如某策略需基于另一策略的结果执行），策略模式本身无法很好地管理这种依赖，需额外引入其他设计模式（如装饰器模式）辅助实现。

四、策略模式的使用场景

策略模式的核心适用场景是“算法需要动态切换、且算法数量较多、需独立扩展”的业务场景。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

  • 算法需动态切换：客户端需根据不同条件，在运行时动态选择不同的算法。典型案例：支付系统（支付宝、微信、银行卡、银联支付）、排序算法（冒泡、快排、归并、插入排序）、日志存储策略（本地文件、数据库、云存储、消息队列）、电商优惠计算（满减、折扣、优惠券、积分抵扣）。

  • 避免大量条件判断：代码中出现大量与算法选择相关的条件分支，且分支逻辑频繁修改、扩展。例如某风控系统，根据用户等级、交易金额、风险评分选择不同的风控策略，若用条件判断会导致代码臃肿，适合用策略模式重构。

  • 算法需独立扩展与维护：算法的实现可能频繁变更，且需要不影响原有调用逻辑。例如电商平台的推荐算法，需根据用户行为、商品热度等因素动态调整推荐策略，新增或修改推荐算法时，无需改动推荐核心逻辑。

  • 多算法复用场景：多个客户端（或场景）需要共享不同的算法，且算法逻辑相对独立。例如办公软件的文件导出策略（PDF、Excel、Word、TXT），不同模块可共享同一套导出策略。

4.2 典型实战案例

  • 支付系统的支付策略：电商平台的支付模块，支持支付宝、微信、银行卡、银联等多种支付方式，每种支付方式的流程（下单、支付、回调）不同，通过策略模式将每种支付方式封装为独立策略，客户端可根据用户选择动态切换支付策略，新增支付方式时无需修改原有支付逻辑。

  • 排序算法的动态选择：数据处理系统中，根据数据量大小、数据类型（有序/无序）选择不同的排序算法（小数据量用冒泡排序，大数据量用快排，有序数据用插入排序），通过策略模式封装每种排序算法，环境类根据数据条件动态切换策略，提升排序效率。

  • 电商优惠计算系统：电商平台的订单结算模块，支持满减、折扣、优惠券、积分抵扣等多种优惠方式，每种优惠的计算逻辑不同，通过策略模式将每种优惠封装为独立策略，根据订单金额、用户等级等条件动态选择优惠策略，新增优惠方式时无需修改结算核心逻辑。

  • 日志存储策略：系统日志需根据不同环境（开发、测试、生产）选择不同的存储方式（开发环境存储本地文件，测试环境存储数据库，生产环境存储云存储），通过策略模式封装每种存储策略，环境类根据配置动态切换存储方式，提升日志存储的灵活性。

4.3 避坑场景

  • 策略数量极少且无扩展计划：若仅存在2-3个策略，且后续无新增策略的需求，用简单的条件判断即可实现，无需引入策略模式，避免过度设计。例如仅支持“加法、减法”两种运算的工具类，无需封装为策略模式。

  • 算法逻辑简单且无变化：若算法逻辑简单，且长期无需修改，无需封装为独立策略，直接在客户端实现即可，减少代码冗余。例如简单的数值转换、字符串拼接等逻辑，无需使用策略模式。

  • 客户端无需动态切换策略：若策略一旦确定，运行时无需切换，且仅在单一场景使用，无需引入策略模式。例如某系统固定使用快排算法，无需支持其他排序方式，直接实现快排逻辑即可。

  • 极致性能敏感的底层场景：如嵌入式实时系统、高频交易系统，策略模式的多态/函数指针调用会带来轻微性能开销，可能影响系统响应速度，需谨慎使用，可考虑用条件判断替代。

五、策略模式的扩展与实战技巧

在实际工程实践中，单纯的策略模式可能无法满足复杂场景的需求，需结合其他设计模式或优化技巧，解决策略模式的固有缺陷（如类爆炸、客户端需了解所有策略），提升系统的灵活性和可维护性。

5.1 策略工厂模式（解决客户端选择策略的复杂度）

为解决“客户端需了解所有策略”的问题，可结合工厂模式，创建策略工厂类（StrategyFactory），由工厂类根据条件（如配置、参数）自动创建并返回具体策略对象，客户端无需直接实例化策略，只需通过工厂类获取策略，降低客户端的使用复杂度。例如支付系统中，客户端只需传入“支付方式编码”，工厂类即可返回对应的支付策略对象。

5.2 策略单例化（优化性能，减少对象创建开销）

具体策略类通常无状态数据（算法逻辑固定），可将其设计为单例，减少对象创建与销毁的开销。例如C#中通过静态只读实例、Python中通过__new__方法、Go中通过全局变量、C++中通过静态成员函数，实现策略对象的单例化，避免频繁创建策略对象，提升系统性能。

5.3 与其他设计模式结合使用

  • 与工厂模式结合：如上述“策略工厂”，由工厂负责策略的创建与管理，客户端通过工厂获取策略，降低客户端与具体策略的耦合，同时简化策略选择逻辑。

  • 与装饰器模式结合：当策略需要新增额外功能（如日志记录、权限校验）时，可通过装饰器模式为策略动态添加功能，无需修改原有策略代码，实现功能的灵活扩展。例如为支付策略添加“支付日志记录”装饰器，无需修改支付策略本身。

  • 与模板方法模式结合：当多个策略存在共同的逻辑（如前置校验、后置处理）时，可通过模板方法模式将共同逻辑封装到抽象策略基类中，具体策略只需实现差异化的核心逻辑，减少代码冗余。

  • 与观察者模式结合：当策略执行完成后，需要通知其他组件（如更新UI、发送消息），可结合观察者模式，让策略作为被观察者，执行完成后通知所有观察者，实现策略与其他组件的解耦。

5.4 多语言实现的注意事项

  • **C#**：通过接口定义抽象策略，用抽象类封装通用逻辑（如日志记录、参数校验），减少重复代码；利用依赖注入框架（如Autofac、Unity）管理策略对象，简化策略的创建与切换；新增策略时，确保接口实现的一致性，可通过代码检查工具校验。

  • Python：无需严格遵循“接口-实现”结构，可通过鸭子类型简化设计；利用装饰器封装通用逻辑（如策略执行日志），提升代码复用性；注意策略对象的内存管理，避免循环引用；可通过字典映射策略标识与策略对象，简化策略选择逻辑。

  • Golang：依托接口的隐式实现特性，简化状态类定义；通过结构体组合复用通用策略逻辑；利用sync.Once实现策略单例，减少对象创建开销；可通过map存储策略标识与策略对象，实现策略的快速查找与切换。

  • **C++**：抽象策略类的析构函数必须声明为虚函数，避免多态场景下的内存泄漏；可通过智能指针（如unique_ptr）管理策略对象，简化内存管理；利用单例模式优化策略对象的创建，提升性能；注意纯虚函数的实现，确保所有具体策略类都实现了抽象接口的方法。

  • 纯C：函数指针需保证类型一致性，避免野指针；通过结构体封装策略相关数据，提升代码可读性；注意内存分配与释放的配对，避免内存泄漏；可通过宏定义或函数指针数组，简化策略的注册与切换逻辑。

六、总结

策略模式的核心精髓是“封装变化、解耦算法”，其本质是通过将易变的算法逻辑抽离为独立的策略组件，实现算法与客户端的解耦，让算法能够灵活切换、独立扩展。它不仅是一种代码组织方式，更是一种“面向变化”的设计思维——面对频繁变更的算法逻辑，不通过修改原有代码实现，而是通过新增策略组件完成扩展，完美契合“开闭原则”。

从多语言实现来看，不同语言的实现方式虽有差异，但核心逻辑高度一致：面向对象语言（C#、Python、C++）可通过接口/抽象类+继承/多态，自然映射策略模式的三大核心角色，代码结构清晰、贴合模式原生设计；Go语言借助接口和结构体，以“组合”思想实现轻量级策略管理，兼顾简洁性与高性能；纯C语言则通过结构体+函数指针，手动模拟面向对象特性，实现策略模式的核心逻辑，体现了模式思想的跨语言适配性。

在实际开发中，使用策略模式的关键是“权衡场景、规避缺陷”：

  • 简单场景（≤3个策略、无扩展计划）：优先使用条件判断，避免过度设计，兼顾开发效率；

  • 复杂场景（≥5个策略、频繁扩展/修改）：果断使用策略模式，结合策略工厂、单例、装饰器等技巧，解决类爆炸、客户端使用复杂等问题；

  • 跨语言开发场景：根据语言特性调整实现方式（如C的函数指针、Go的接口），核心保持“策略封装、动态切换”的设计思想；

  • 性能敏感场景：通过策略单例、对象池化等方式，降低性能开销，必要时可放弃策略模式，选择条件判断。

总之，策略模式是解决“算法动态切换、独立扩展”类问题的有效工具，合理使用可让复杂的算法逻辑更清晰、更易维护，滥用则会增加系统复杂度。开发者需结合业务实际，灵活运用策略模式及扩展技巧，在设计优雅与开发效率之间找到平衡，构建高可维护、高扩展的系统。

发表于 更新于 分类于 ，

状态模式（State Pattern）是一种经典的行为型设计模式，其核心思想是：允许对象在内部状态发生改变时，动态调整自身行为，使得对象看起来仿佛“修改了自身的类”。该模式通过将不同状态封装为独立的状态对象，将状态转换逻辑委托给这些对象，彻底摒弃复杂的条件分支判断，有效提升代码的可维护性、扩展性与可读性，是解决“状态驱动行为变化”类问题的最优方案之一。

一、状态模式核心结构

状态模式的设计核心的是“状态与行为解耦”，通过明确的角色分工，实现状态流转的灵活管理与行为逻辑的模块化封装。其核心角色分为三类，各角色职责清晰、协同工作，构成完整的状态驱动体系：

1.1 上下文（Context）

作为状态的“容器”与“调度中心”，上下文类维护一个当前状态对象的引用，对外提供统一的交互接口（如请求处理方法），并负责将所有与状态相关的请求，委派给当前的状态对象处理。同时，上下文也提供状态切换的入口，允许状态对象通过它完成状态更新，自身无需关注具体的状态逻辑。

1.2 抽象状态（State）

定义所有具体状态类的公共行为契约，通常以接口（面向对象语言）或函数指针（无面向对象特性语言）的形式存在。它声明了与上下文交互的核心方法，规范了具体状态类必须实现的行为，确保上下文能通过统一接口调用不同状态的逻辑。

1.3 具体状态（ConcreteState）

抽象状态的具体实现，是状态行为的核心载体。它不仅封装了对应状态下的具体业务逻辑，还可包含状态转换的决策逻辑——根据业务规则，判断何时切换到其他状态，并通过上下文完成状态更新。不同的具体状态类，对应对象在不同状态下的差异化行为。

核心流转逻辑：上下文持有抽象状态引用 → 接收外部请求 → 委派请求给当前具体状态对象 → 具体状态执行行为逻辑 → 必要时通过上下文切换状态 → 上下文更新当前状态，完成一次状态驱动的行为闭环。

二、多语言实现状态模式

为便于不同技术栈开发者落地实践，本文以“状态切换演示”为统一案例（通过两种状态的交替切换，直观呈现状态模式的核心逻辑），分别提供C#、Python、Golang、C++及纯C语言的可运行实现。各实现均贴合语言特性，补充规范注释、异常处理与边界校验，兼顾实用性与严谨性，清晰展现状态模式在不同语言中的适配思路。

2.1 C# 实现（面向对象规范实现）

C# 作为强类型面向对象语言，通过接口严格定义抽象状态契约，依托类的继承与多态实现具体状态逻辑，上下文通过属性封装状态引用，确保状态管理的安全性与规范性，适配企业级业务系统开发。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
using System;

/// <summary>
/// 抽象状态接口：定义状态的核心行为契约
/// </summary>
public interface IState
{
    /// <summary>
    /// 处理状态相关请求，包含状态转换逻辑
    /// </summary>
    /// <param name="context">上下文对象</param>
    void Handle(Context context);
}

/// <summary>
/// 具体状态A：实现状态A的行为与转换逻辑
/// </summary>
public class ConcreteStateA : IState
{
    public void Handle(Context context)
    {
        Console.WriteLine("执行状态A的核心行为，触发状态切换至B");
        // 通过上下文切换状态，状态转换逻辑封装在具体状态中
        context.State = new ConcreteStateB();
    }
}

/// <summary>
/// 具体状态B：实现状态B的行为与转换逻辑
/// </summary>
public class ConcreteStateB : IState
{
    public void Handle(Context context)
    {
        Console.WriteLine("执行状态B的核心行为，触发状态切换至A");
        context.State = new ConcreteStateA();
    }
}

/// <summary>
/// 上下文类：管理状态引用，委派请求处理
/// </summary>
public class Context
{
    // 私有字段存储当前状态，通过属性对外暴露，避免直接修改
    private IState _currentState;

    /// <summary>
    /// 初始化上下文，指定初始状态
    /// </summary>
    /// <param name="initialState">初始状态对象</param>
    public Context(IState initialState)
    {
        State = initialState ?? throw new ArgumentNullException(nameof(initialState), "初始状态不可为null");
    }

    /// <summary>
    /// 当前状态属性，设置时打印状态切换日志
    /// </summary>
    public IState State
    {
        get => _currentState;
        set
        {
            _currentState = value;
            Console.WriteLine($"状态切换完成，当前状态：{_currentState.GetType().Name}");
        }
    }

    /// <summary>
    /// 对外统一请求接口，委派给当前状态处理
    /// </summary>
    public void Request()
    {
        _currentState.Handle(this);
    }
}

// 客户端测试代码
class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 初始化上下文，设置初始状态为A
            Context context = new Context(new ConcreteStateA());
            // 触发两次请求，观察状态交替切换
            context.Request(); // 状态A → 状态B
            context.Request(); // 状态B → 状态A
        }
        catch (Exception ex)
        {
            Console.WriteLine($"执行异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过基类约定抽象状态的行为，语法简洁、无繁琐类型声明。依托动态类型特性，上下文可灵活切换状态对象，适配快速开发、脚本开发及轻量级项目，完美保留状态模式的核心逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class State:
    """抽象状态基类：约定状态的核心行为"""
    def handle(self, context):
        """处理状态请求，子类需重写该方法"""
        raise NotImplementedError("具体状态类必须实现handle方法")

class ConcreteStateA(State):
    """具体状态A：实现状态A的行为与转换逻辑"""
    def handle(self, context):
        print("执行状态A的核心行为，触发状态切换至B")
        # 切换状态，直接修改上下文的状态属性
        context.state = ConcreteStateB()

class ConcreteStateB(State):
    """具体状态B：实现状态B的行为与转换逻辑"""
    def handle(self, context):
        print("执行状态B的核心行为，触发状态切换至A")
        context.state = ConcreteStateA()

class Context:
    """上下文类：管理状态，委派请求处理"""
    def __init__(self, initial_state):
        """初始化上下文，指定初始状态"""
        if not isinstance(initial_state, State):
            raise TypeError("初始状态必须是State的子类实例")
        self._state = initial_state

    @property
    def state(self):
        """当前状态属性（只读）"""
        return self._state

    @state.setter
    def state(self, new_state):
        """设置当前状态，打印切换日志"""
        if not isinstance(new_state, State):
            raise TypeError("新状态必须是State的子类实例")
        self._state = new_state
        print(f"状态切换完成，当前状态：{new_state.__class__.__name__}")

    def request(self):
        """对外统一请求接口，委派给当前状态处理"""
        self._state.handle(self)

# 客户端测试代码
if __name__ == "__main__":
    try:
        # 初始化上下文，设置初始状态为A
        context = Context(ConcreteStateA())
        # 触发请求，观察状态切换
        context.request()  # 状态A → 状态B
        context.request()  # 状态B → 状态A
    except Exception as e:
        print(f"执行异常：{str(e)}")

2.3 Golang 实现（接口至上轻量实现）

Go 语言无类和继承，核心遵循“组合优于继承”原则，通过接口定义抽象状态契约，结构体实现具体状态逻辑，代码极简高效。依托接口的隐式实现特性，无需显式声明继承关系，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发后端开发场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package main

import "fmt"

// State 抽象状态接口：定义状态的核心行为
type State interface {
        Hontext *Context) // 处理请求，包含状态转换逻辑
}

// ConcreteStateA 具体状态A
type ConcreteStateA struct{}

// Handle 实现状态A的行为与转换逻辑
func (s *ConcreteStateA) Handle(context *Context) {
 fmt.Println("执行状态A的核心行为，触发状态切换至B")
        coetState(&ConcreteStateB{})
}

// ConcreteStateB 具体状态B
type ConcreteStateB struct{}

// Handle 实现状态B的行为与转换逻辑
func (s *ConcreteStateB) Handle(context *Context) {
        fmln("执行状态B的核心行为，触发状态切换至A")
   ntext.SetState(&ConcreteStateA{})
}

// Context 上下文结构体：管理状态，委派请求
type Context struct {
        curre State // 当前状态引用
}

// NewContext 工厂函数：创建上下文实例，指定初始状态
func NewContext(initialState State) *Context {
        ialState == nil {
    t.Println("初始状态不可为nil")
  return nil
 }
     rn &Context{currentState: initialState}
}

// SetState 设置当前状态，打印切换日志
func (c *Context) SetState(newState State) {
  f newState == nil {
              "新状态不可为nil")
        
        }
        c.curretate
      rintf("状态切换完成，当前状态：%T\n", newState)
}

// Request 对外统一请求接口，委派给当前状态处理
func (c *Context) Request() {
    c.currentState == nil {
          tln("当前状态未初始化，无法处理请求")
        
        }
       e.Handle(c)
}

// 客户端测试代码
func main() {
        // 初始化上下态为A
         := NewContext(&ConcreteStateA{})
 if context == nil {
              / 触发请求，观察状态切换
   ntext.Request() // 状态A → 状态B
     ext.Request() // 状态B → 状态A
}
         cont     co  return
        }
        /       context文，设置初始状 c.currentStat return             fmt.Prin     if  fmt.PntState = newS        return  fmt.Println(      i   retu                                 fmif initentStat     cot.Printntext.S       andle(c

2.4 C++ 实现（抽象类+多态经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象状态接口，子类继承并实现具体状态逻辑，依托多态特性实现状态的灵活切换。需手动管理内存（通过虚析构函数避免内存泄漏），兼顾灵活性与高性能，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <iostream>
#include <typeinfo>
using namespace std;

// 前向声明上下文类，解决交叉引用问题
class Context;

// 抽象状态类：纯虚函数定义接口
class State {
public:
    virtual ~State() = default; // 虚析构函数，避免多态场景内存泄漏
    /// <summary>
    /// 处理状态请求，子类必须实现
    /// </summary>
    /// <param name="context">上下文对象指针</param>
    virtual void Handle(Context* context) = 0;
};

// 上下文类：管理状态，委派请求处理
class Context {
private:
    State* currentState; // 当前状态指针
public:
    /// <summary>
    /// 初始化上下文，指定初始状态
    /// </summary>
    /// <param name="initialState">初始状态指针</param>
    Context(State* initialState) : currentState(initialState) {
        if (initialState == nullptr)
            throw invalid_argument("初始状态不可为nullptr");
    }

    /// <summary>
    /// 析构函数：释放状态对象内存
    /// </summary>
    ~Context() {
        delete currentState;
        currentState = nullptr;
    }

    /// <summary>
    /// 设置当前状态，打印切换日志
    /// </summary>
    /// <param name="newState">新状态指针</param>
    void SetState(State* newState) {
        if (newState == nullptr)
            throw invalid_argument("新状态不可为nullptr");
        delete currentState; // 释放旧状态内存
        currentState = newState;
        cout << "状态切换完成，当前状态：" << typeid(*currentState).name() << endl;
    }

    /// <summary>
    /// 对外统一请求接口，委派给当前状态处理
    /// </summary>
    void Request() {
        currentState->Handle(this);
    }
};

// 具体状态A：继承抽象状态，实现核心逻辑
class ConcreteStateA : public State {
public:
    void Handle(Context* context) override {
        cout << "执行状态A的核心行为，触发状态切换至B" << endl;
        context->SetState(new ConcreteStateB());
    }
};

// 具体状态B：继承抽象状态，实现核心逻辑
class ConcreteStateB : public State {
public:
    void Handle(Context* context) override {
        cout << "执行状态B的核心行为，触发状态切换至A" << endl;
        context->SetState(new ConcreteStateA());
    }
};

// 客户端测试代码
int main() {
    try {
        // 初始化上下文，设置初始状态为A
        Context* context = new Context(new ConcreteStateA());
        // 触发请求，观察状态切换
        context->Request(); // 状态A → 状态B
        context->Request(); // 状态B → 状态A

        // 释放上下文内存（会自动释放状态对象）
        delete context;
        context = nullptr;
    }
    catch (const exception& e) {
        cout << "执行异常：" << e.what() << endl;
    }
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为”，手动模拟状态模式的核心逻辑。用结构体封装上下文和状态的属性，用函数指针模拟抽象状态的接口方法，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“状态封装、行为委派”的核心思想。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 前向声明上下文结构体，解决交叉引用问题
typedef struct Context Context;

// 状态处理函数指针类型（模拟抽象状态接口）
typedef void (*StateHandleFunc)(Context*);

// 上下文结构体：管理当前状态（函数指针）
struct Context {
    StateHandleFunc currentHandle; // 当前状态的处理函数
};

// 具体状态A的处理函数：实现状态A的行为与转换逻辑
void ConcreteStateA_Handle(Context* context);
// 具体状态B的处理函数：实现状态B的行为与转换逻辑
void ConcreteStateB_Handle(Context* context);

// 具体状态A的处理逻辑
void ConcreteStateA_Handle(Context* context) {
    if (context == NULL) {
        printf("上下文不可为NULL\n");
        return;
    }
    printf("执行状态A的核心行为，触发状态切换至B\n");
    // 切换状态：修改上下文的函数指针
    context->currentHandle = ConcreteStateB_Handle;
    printf("状态切换完成，当前状态：ConcreteStateB\n");
}

// 具体状态B的处理逻辑
void ConcreteStateB_Handle(Context* context) {
    if (context == NULL) {
        printf("上下文不可为NULL\n");
        return;
    }
    printf("执行状态B的核心行为，触发状态切换至A\n");
    context->currentHandle = ConcreteStateA_Handle;
    printf("状态切换完成，当前状态：ConcreteStateA\n");
}

// 工厂函数：创建上下文实例，指定初始状态
Context* Context_Create(StateHandleFunc initialHandle) {
    if (initialHandle == NULL) {
        printf("初始状态处理函数不可为NULL\n");
        return NULL;
    }
    Context* context = (Context*)malloc(sizeof(Context));
    if (context == NULL) {
        printf("内存分配失败，无法创建上下文\n");
        return NULL;
    }
    context->currentHandle = initialHandle;
    return context;
}

// 上下文请求处理函数：委派给当前状态的处理函数
void Context_Request(Context* context) {
    if (context == NULL || context->currentHandle == NULL) {
        printf("上下文未初始化或状态无效，无法处理请求\n");
        return;
    }
    context->currentHandle(context);
}

// 释放上下文内存
void Context_Destroy(Context* context) {
    if (context != NULL) {
        free(context);
        context = NULL;
    }
}

// 客户端测试代码
int main() {
    // 初始化上下文，设置初始状态为A
    Context* context = Context_Create(ConcreteStateA_Handle);
    if (context == NULL) {
        return -1;
    }

    // 触发请求，观察状态切换
    Context_Request(context); // 状态A → 状态B
    Context_Request(context); // 状态B → 状态A

    // 释放内存
    Context_Destroy(context);
    return 0;
}

三、状态模式的优缺点

状态模式的核心价值的是“解耦状态与行为，消除复杂条件分支”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的状态数量、流转复杂度和性能要求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题。

3.1 核心优点

  • 消除复杂条件分支，提升代码可读性：将不同状态的行为逻辑封装到独立的状态类中，彻底替代大量嵌套的if/else或switch语句，让代码结构更清晰，逻辑更易理解。例如电商订单的多状态流转，若用条件判断需覆盖待支付、已支付、已发货等所有分支，而状态模式只需为每个状态定义独立逻辑，可读性大幅提升。

  • 状态与行为解耦，提升可维护性：每个状态的行为独立封装，修改某一状态的逻辑时，无需改动其他状态和上下文代码，降低维护成本。同时，状态逻辑的模块化的设计，也便于单独调试和测试。

  • 符合开闭原则，扩展性极强：新增状态时，只需添加新的具体状态类，实现抽象状态接口，无需修改上下文和已有状态代码，即可完成功能扩展。例如为电梯系统新增“故障”状态，仅需实现ConcreteStateFault类，上下文无需任何改动。

  • 状态流转清晰可控，便于问题定位：状态转换逻辑集中在具体状态类中，可通过日志快速跟踪状态流转路径，定位状态切换异常的问题。同时，上下文统一管理状态引用，避免状态混乱。

  • 状态行为可复用：相同的状态逻辑可在不同的上下文或业务场景中复用，例如“待机”状态，可在游戏角色、智能设备等多个场景中复用，减少代码冗余。

3.2 主要缺点

  • 类/结构体膨胀，增加维护成本：每个状态对应一个具体类（或结构体+函数），当状态数量较多时（如10个以上），会导致类/结构体数量激增，增加代码量和维护成本，甚至出现“类爆炸”问题。

  • 状态转换逻辑分散，全局把控难度大：状态转换逻辑分散在各个具体状态类中，对于复杂状态机（多状态、多流转规则），难以全局把控所有状态的流转关系，修改全局流转规则时，可能需要修改多个状态类。

  • 存在过度设计风险：对于简单状态场景（如仅2-3个状态，且无扩展计划），使用状态模式会增加设计复杂度，显得冗余。例如仅包含“开启/关闭”的设备状态，用简单的布尔变量+条件判断即可实现，无需引入状态模式。

  • 上下文与状态存在耦合：具体状态类通常需要持有上下文引用以完成状态切换，导致状态类与上下文的耦合度升高。若上下文的结构或接口发生变更，需同步修改所有关联的状态类。

  • 轻微性能开销：状态模式的多态调用（或函数指针调用）会带来轻微的性能开销，在极致性能要求的底层场景（如嵌入式实时系统），需谨慎使用。

四、状态模式的使用场景

状态模式的核心适用场景是“对象行为随状态动态变化，且状态流转复杂、需频繁扩展”的业务场景。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

  • 对象行为随状态动态变化：对象在不同状态下表现出截然不同的行为，且状态切换频繁。典型案例：电梯（停止、运行、开门、关门、故障）、订单（待支付、已支付、已发货、已完成、已取消）、游戏角色（待机、移动、攻击、受伤、死亡）、网络连接（连接中、已连接、断开连接、重连）。

  • 避免复杂条件分支：代码中出现大量与状态相关的条件分支，且分支逻辑频繁修改、扩展。例如某设备控制逻辑，包含5种以上状态，每种状态对应不同的操作逻辑，若用条件判断会导致代码臃肿、难以维护，适合使用状态模式重构。

  • 状态转换规则明确：状态之间的流转规则清晰，且需要灵活扩展状态或修改转换逻辑。典型案例：编译器的语法分析状态机（不同语法节点对应不同解析状态，需支持新增语法规则）、工作流引擎（流程节点的状态流转，支持动态配置）。

  • 需要统一管理状态行为：不同状态下的行为差异较大，且希望将状态相关行为集中管理，便于测试和维护。典型案例：智能家居设备的模式切换（空调的制冷、制热、送风、除湿模式）、支付系统的支付状态管理（待支付、支付中、支付成功、支付失败）。

4.2 典型实战案例

  • 电商订单状态流转：订单从创建到完成，需经历待支付、已支付、已发货、已完成、已取消等多个状态，每个状态对应不同的业务逻辑（如待支付状态可取消订单，已支付状态可申请退款），状态转换规则明确，适合用状态模式实现，便于后续新增“退款中”“售后中”等状态。

  • 电梯控制系统：电梯包含停止、运行、开门、关门、故障等状态，不同状态下的行为逻辑不同（如运行状态无法开门，开门状态无法运行），状态转换需遵循严格规则，用状态模式可清晰管理各状态的行为和流转，避免复杂条件判断。

  • 游戏角色状态管理：游戏角色的待机、移动、攻击、受伤、死亡等状态，每种状态对应不同的动画、音效和行为逻辑（如受伤状态移动速度降低，死亡状态无法执行任何操作），状态切换频繁，用状态模式可灵活扩展新状态（如“眩晕”“无敌”），且不影响原有逻辑。

  • 网络连接状态管理：客户端与服务器的连接状态（连接中、已连接、断开连接、重连），不同状态下的行为逻辑不同（如已连接状态可发送数据，断开连接状态需触发重连），用状态模式可统一管理连接状态，简化重连逻辑和数据发送逻辑。

4.3 避坑场景

  • 状态数量极少且无扩展计划：若仅存在2-3个状态，且后续无新增状态的需求，用简单的条件判断即可实现，无需引入状态模式，避免过度设计。

  • 状态转换规则混乱无规律：状态模式依赖清晰的状态流转逻辑，若状态之间的转换无固定规则，会导致状态类逻辑混乱，难以维护，此时不适合使用状态模式。

  • 极致性能敏感的底层场景：如嵌入式实时系统、高频交易系统，状态模式的多态/函数指针调用会带来轻微性能开销，可能影响系统响应速度，需谨慎使用，可考虑用条件判断替代。

  • 上下文频繁变更的场景：若上下文的结构或接口频繁变更，会导致所有关联的状态类同步修改，增加维护成本，此时需先优化上下文设计，再考虑是否使用状态模式。

五、状态模式的扩展与实战技巧

在实际工程实践中，单纯的状态模式可能无法满足复杂场景的需求，需结合其他设计模式或优化技巧，解决状态模式的固有缺陷（如类膨胀、逻辑分散），提升系统的灵活性和可维护性。

5.1 状态管理器优化（解决逻辑分散问题）

对于复杂状态机（多状态、多流转规则），可引入“状态管理器”（StateManager）统一管理状态转换规则，替代分散在具体状态类中的转换逻辑。状态管理器负责校验状态转换的合法性、记录状态流转日志、维护状态流转规则表，具体状态类仅需实现自身的业务行为，无需关注状态转换逻辑，从而实现“行为与流转规则”的解耦。

例如，电商订单的状态流转规则可配置在状态管理器中，当订单需要切换状态时，由状态管理器校验流转是否合法（如待支付状态可切换至已支付或已取消，已发货状态不可切换至待支付），通过配置化的方式，减少状态类的逻辑冗余，便于全局修改流转规则。

5.2 与其他设计模式结合使用

  • 与单例模式结合：具体状态类通常无状态数据（行为逻辑固定），可设计为单例，减少对象创建开销。例如C#中通过静态只读实例、Python中通过__new__方法、Go中通过全局变量，实现状态对象的单例化，避免频繁创建状态对象。

  • 与工厂模式结合：通过状态工厂类（StateFactory）创建具体状态对象，降低上下文与具体状态类的耦合。上下文无需直接实例化具体状态类，只需通过工厂类获取状态对象，新增状态时，仅需修改工厂类，无需改动上下文代码。

  • 与策略模式结合：状态模式与策略模式结构相似，核心区别在于：状态模式关注“状态驱动的行为变化”，状态切换由内部逻辑触发；策略模式关注“算法替换”，策略选择由外部逻辑触发。两者结合可实现“状态+算法”的双层灵活扩展，例如游戏角色的“攻击状态”，可搭配不同的攻击策略（近战、远程、魔法），提升系统的灵活性。

  • 与观察者模式结合：当状态切换时，需要通知其他组件（如UI更新、日志记录），可结合观察者模式，让上下文作为被观察者，状态切换时通知所有观察者，实现状态变更的联动效果，避免状态类与其他组件的直接耦合。

5.3 多语言实现的注意事项

  • **C#**：通过接口定义抽象状态，用抽象类封装通用状态逻辑（如日志记录），减少重复代码；利用属性封装状态引用，避免外部直接修改状态；新增状态时，确保接口实现的一致性，可通过代码检查工具校验。

  • Python：无需严格遵循“接口-实现”结构，可通过鸭子类型简化设计；注意状态对象的内存管理，避免循环引用（如上下文与状态相互引用）；利用装饰器封装通用逻辑（如状态切换日志），提升代码复用性。

  • Golang：依托接口的隐式实现特性，简化状态类定义；通过结构体组合复用通用状态逻辑（如将日志记录逻辑封装为单独的结构体，嵌入具体状态结构体）；注意状态接口的方法签名一致性，避免隐式实现失败。

  • **C++**：抽象状态类的析构函数必须声明为虚函数，避免多态场景下的内存泄漏；可通过智能指针（如unique_ptr）管理状态对象，简化内存管理；注意纯虚函数的实现，确保所有具体状态类都实现了抽象接口的方法。

  • 纯C：函数指针需保证类型一致性，避免野指针；通过结构体封装状态相关数据，提升代码可读性；注意内存分配与释放的配对，避免内存泄漏；可通过宏定义简化状态切换的代码，减少冗余。

六、总结

状态模式的核心精髓是“将状态封装为独立对象，让行为随状态动态切换”，其本质是通过解耦状态与行为，消除复杂条件分支，提升代码的可维护性、扩展性与可读性。它不仅是一种代码组织方式，更是一种“状态驱动”的设计思维——让对象的行为由其内部状态决定，而非外部条件判断，从而让系统更易应对复杂的状态变化和需求迭代。

从多语言实现来看，不同语言的实现方式虽有差异，但核心逻辑高度一致：面向对象语言（C#、Python、C++）可通过接口/抽象类+继承/多态，自然映射状态模式的三大核心角色，代码结构清晰、贴合模式原生设计；Go语言借助接口和结构体，以“组合”思想实现轻量级状态管理，兼顾简洁性与高性能；纯C语言则通过结构体+函数指针，手动模拟面向对象特性，实现状态模式的核心逻辑，体现了模式思想的跨语言适配性。

在实际开发中，使用状态模式的关键是“权衡场景、规避缺陷”：

  • 简单场景（≤3个状态、无扩展计划）：优先使用条件判断，避免过度设计，兼顾开发效率；

  • 复杂场景（≥5个状态、频繁扩展/修改）：果断使用状态模式，结合状态管理器、单例、工厂等技巧，解决类膨胀、逻辑分散等问题；

  • 跨语言开发场景：根据语言特性调整实现方式（如C的函数指针、Go的接口），核心保持“状态封装、行为委派”的设计思想；

  • 性能敏感场景：谨慎使用，可通过优化状态切换逻辑、减少多态调用，降低性能开销。

总之，状态模式是解决“状态驱动行为变化”类问题的有效工具，合理使用可让复杂状态流转逻辑更清晰、更易维护，滥用则会增加系统复杂度。开发者需结合业务实际，灵活运用状态模式及扩展技巧，在设计优雅与开发效率之间找到平衡，构建高可维护、高扩展的系统。

0%