C++信息论超详解析

代码接入中...大家好，今天是开更后第二篇文章。

[C++ 信息论完整教程（纯文字+代码合计）](#C++ 信息论完整教程（纯文字+代码合计）)
- 前言
- 目录
- - 第一部分：信息论基础理论
  - 第二部分：信息论核心度量
  - [第三部分：C++ 信息论核心代码实现（约4500字）](#第三部分：C++ 信息论核心代码实现（约4500字）)
  - 第四部分：完整可运行C++信息论工具库
  - 第五部分：信息论高级定理与应用
  - 第六部分：信息论工程实践
第一部分：信息论基础理论
- [1.1 信息的定义与量化](#1.1 信息的定义与量化)
- [1.2 自信息（Self-Information）](#1.2 自信息（Self-Information）)
- [1.3 概率分布与离散随机变量](#1.3 概率分布与离散随机变量)
- [1.4 信息论的核心研究对象](#1.4 信息论的核心研究对象)
- [1.5 信息论的应用领域](#1.5 信息论的应用领域)
第二部分：信息论核心度量
- [2.1 香农熵（Shannon Entropy）](#2.1 香农熵（Shannon Entropy）)
- [2.2 联合熵（Joint Entropy）](#2.2 联合熵（Joint Entropy）)
- - 定义
  - 核心性质
- [2.3 条件熵（Conditional Entropy）](#2.3 条件熵（Conditional Entropy）)
- - 定义
  - 物理意义
- [2.4 互信息（Mutual Information）](#2.4 互信息（Mutual Information）)
- - 定义
  - 核心性质
- [2.5 相对熵（KL散度）](#2.5 相对熵（KL散度）)
- - 定义
  - 核心性质
- [2.6 交叉熵（Cross Entropy）](#2.6 交叉熵（Cross Entropy）)
- - 定义
  - 核心关系
- [2.7 信息增益与信息增益比](#2.7 信息增益与信息增益比)
- - 定义
[第三部分：C++ 信息论核心代码实现](#第三部分：C++ 信息论核心代码实现)
- [3.1 基础工具函数](#3.1 基础工具函数)
- [3.2 自信息与香农熵实现](#3.2 自信息与香农熵实现)
- [3.3 联合熵与条件熵实现](#3.3 联合熵与条件熵实现)
- [3.4 互信息实现](#3.4 互信息实现)
- [3.5 KL散度与交叉熵实现](#3.5 KL散度与交叉熵实现)
- [3.6 文本熵计算实现](#3.6 文本熵计算实现)
- [3.7 信息增益实现](#3.7 信息增益实现)
第四部分：完整可运行C++信息论工具库
- [4.1 全模块整合代码](#4.1 全模块整合代码)
- [4.2 运行说明](#4.2 运行说明)
第五部分：信息论高级定理与应用
- [5.1 香农三大定理](#5.1 香农三大定理)
- [5.2 数据压缩极限](#5.2 数据压缩极限)
- [5.3 最大熵原理](#5.3 最大熵原理)
第六部分：信息论工程实践
- [6.1 文本加密检测](#6.1 文本加密检测)
- [6.2 数据压缩率评估](#6.2 数据压缩率评估)
- [6.3 机器学习特征筛选](#6.3 机器学习特征筛选)
全文总结

C++ 信息论完整教程（纯文字+代码合计）

前言

信息论是由克劳德·香农于1948年创立的一门跨学科理论，它以数学为基础，量化信息、不确定性、冗余度、数据压缩极限、信道传输能力，是现代计算机科学、通信工程、人工智能、数据压缩、密码学的核心基石。没有信息论，就没有互联网、5G通信、数据压缩算法、神经网络训练、加密传输等现代技术。

对于C++开发者而言，信息论不仅是理论知识，更是工程实践的必备工具：文本熵计算可用于文本分类、加密检测；交叉熵是深度学习最核心的损失函数；互信息可用于机器学习特征选择；KL散度用于分布对齐；信道编码定理指导通信协议设计。本教程从零开始，系统讲解信息论所有核心知识点，搭配纯C++可运行代码，覆盖理论、推导、实现、工程应用，全文严格满足2万字要求，兼顾学术严谨性与工程实用性。

本教程分为基础概念、核心度量、高级度量、工程实现、完整工具库、应用场景、定理总结七大模块，所有公式附带中文解释，所有代码可直接编译运行，适配C++11及以上标准，无需第三方库，纯原生实现，适合竞赛、科研、工程开发、学习备考使用。

第一部分：信息论基础理论

1.1 信息的定义与量化

在日常生活中，信息是用来消除不确定性的内容，比如一句话、一段数据、一个信号。但在信息论中，信息是可以被数学量化的物理量，它的大小与事件发生的概率直接相关：事件发生的概率越低，一旦发生，携带的信息量就越大；事件发生的概率越高，信息量越小。

举个例子："太阳从东方升起"是必然事件，概率为1，信息量为0，因为这句话没有消除任何不确定性；"明天发生地震"是小概率事件，一旦发生，信息量极大，因为它消除了极大的未知性。这就是信息量化的核心逻辑：信息量与事件发生概率成负相关。

信息论不关心信息的语义（内容含义），只关心信息的统计特性，这是香农信息论与日常认知最大的区别。它将所有信息源抽象为随机变量，通过概率分布计算信息量，这使得信息论可以适用于所有类型的信息：文本、图像、音频、视频、信号等。

1.2 自信息（Self-Information）

自信息是信息论中最基础的概念，用于描述单个随机事件发生时携带的信息量。

定义

对于离散随机变量 X X X，事件 x x x 发生的概率为 p ( x ) p(x) p(x)，则该事件的自信息为：
I ( x ) = − log ⁡ b p ( x ) I(x) = -\log_b p(x) I(x)=−logbp(x)

单位

以2为底：单位为比特（bit），计算机与通信领域最常用；
以e为底：单位为奈特（nat），数学分析常用；
以10为底：单位为哈特（Hart），工程统计常用。

本教程统一使用以2为底的对数，单位为比特，这是C++实现的标准选择。

核心性质

非负性： I ( x ) ≥ 0 I(x) \geq 0 I(x)≥0，概率越小，自信息越大；
单调性：概率 p ( x ) p(x) p(x) 越大，自信息 I ( x ) I(x) I(x) 越小；
可加性：两个独立事件同时发生的自信息等于各自自信息之和。

必然事件 p ( x ) = 1 p(x)=1 p(x)=1，自信息 I ( x ) = 0 I(x)=0 I(x)=0；不可能事件 p ( x ) = 0 p(x)=0 p(x)=0，自信息趋近于无穷大。

1.3 概率分布与离散随机变量

信息论的所有计算都基于离散随机变量的概率分布。离散随机变量是指取值有限或可数的随机变量，比如抛硬币（正面/反面）、骰子点数（1-6）、文本字符（a-z）。

概率分布满足两个条件：

所有事件的概率非负： p ( x i ) ≥ 0 p(x_i) \geq 0 p(xi)≥0；
所有事件的概率之和为1： ∑ i = 1 n p ( x i ) = 1 \sum_{i=1}^n p(x_i) = 1 ∑i=1np(xi)=1。

在工程实践中，我们无法直接获得理论概率，只能通过频数统计 计算经验概率：
p ( x i ) = c o u n t ( x i ) ∑ j = 1 n c o u n t ( x j ) p(x_i) = \frac{count(x_i)}{\sum_{j=1}^n count(x_j)} p(xi)=∑j=1ncount(xj)count(xi)

其中 c o u n t ( x i ) count(x_i) count(xi) 是事件 x i x_i xi 出现的次数，这是C++实现信息论计算的核心数据来源。

1.4 信息论的核心研究对象

信息论主要研究四大核心对象：

信源：产生信息的源头，如文本、语音、图像，用随机变量描述；
信道：传输信息的通道，如网线、光纤、无线电，存在噪声与干扰；
信宿：接收信息的对象，如计算机、手机；
编码：将信息转换为适合传输/存储的形式，分为信源编码（压缩）和信道编码（纠错）。

信息论的核心目标：

信源编码：在不丢失信息的前提下，最小化数据长度（数据压缩）；
信道编码：在有噪声的信道中，最大化传输速率，保证信息无差错传输。

1.5 信息论的应用领域

数据压缩：ZIP、PNG、JPEG、MP3、H.265等压缩算法的理论基础；
通信工程：5G、卫星通信、光纤通信的信道容量计算、纠错码设计；
人工智能：交叉熵损失函数、互信息特征选择、GAN分布对齐；
密码学：信息熵用于衡量密码系统的安全性；
数据挖掘：文本分类、异常检测、聚类分析；
生物学：DNA序列熵分析、基因信息研究；
金融：风险评估、市场不确定性度量。

第二部分：信息论核心度量

2.1 香农熵（Shannon Entropy）

香农熵是信息论的核心，它是随机变量的平均自信息 ，用来量化随机变量的不确定性。

定义

对于离散随机变量 X X X，其概率分布为 p ( x 1 ) , p ( x 2 ) , . . . , p ( x n ) p(x_1),p(x_2),...,p(x_n) p(x1),p(x2),...,p(xn)，香农熵为：
H ( X ) = − ∑ i = 1 n p ( x i ) log ⁡ 2 p ( x i ) H(X) = -\sum_{i=1}^n p(x_i) \log_2 p(x_i) H(X)=−i=1∑np(xi)log2p(xi)

物理意义

熵越大 → 随机变量的不确定性越高，数据越混乱；
熵越小 → 随机变量的确定性越高，数据越有序；
熵的取值范围： 0 ≤ H ( X ) ≤ log ⁡ 2 n 0 \leq H(X) \leq \log_2 n 0≤H(X)≤log2n；
均匀分布时熵最大，确定分布（一个事件概率为1）熵为0。

举例

抛均匀硬币： p ( 正 ) = p ( 反 ) = 0.5 p(正)=p(反)=0.5 p(正)=p(反)=0.5，熵 H ( X ) = − 0.5 log ⁡ 2 0.5 − 0.5 log ⁡ 2 0.5 = 1 H(X) = -0.5\log_20.5 -0.5\log_20.5 = 1 H(X)=−0.5log20.5−0.5log20.5=1 比特；

抛确定硬币（永远正面）：熵 H ( X ) = 0 H(X)=0 H(X)=0。

香农熵也是数据压缩的理论极限：最优压缩算法的平均码长不小于信源的熵。

2.2 联合熵（Joint Entropy）

联合熵描述两个随机变量同时存在时的总不确定性。

定义

对于两个离散随机变量 X X X 和 Y Y Y，联合概率分布为 p ( x i , y j ) p(x_i,y_j) p(xi,yj)，联合熵为：
H ( X , Y ) = − ∑ i ∑ j p ( x i , y j ) log ⁡ 2 p ( x i , y j ) H(X,Y) = -\sum_{i}\sum_{j} p(x_i,y_j) \log_2 p(x_i,y_j) H(X,Y)=−i∑j∑p(xi,yj)log2p(xi,yj)

核心性质

非负性： H ( X , Y ) ≥ 0 H(X,Y) \geq 0 H(X,Y)≥0；
对称性： H ( X , Y ) = H ( Y , X ) H(X,Y)=H(Y,X) H(X,Y)=H(Y,X)；
单调性： H ( X , Y ) ≥ max ⁡ ( H ( X ) , H ( Y ) ) H(X,Y) \geq \max(H(X),H(Y)) H(X,Y)≥max(H(X),H(Y))；
独立变量： H ( X , Y ) = H ( X ) + H ( Y ) H(X,Y)=H(X)+H(Y) H(X,Y)=H(X)+H(Y)。

2.3 条件熵（Conditional Entropy）

条件熵描述已知一个随机变量的取值后，另一个随机变量剩余的不确定性。

定义

已知 X X X 时， Y Y Y 的条件熵：
H ( Y ∣ X ) = H ( X , Y ) − H ( X ) H(Y|X) = H(X,Y) - H(X) H(Y∣X)=H(X,Y)−H(X)

物理意义

条件熵衡量了两个变量的依赖程度 ：如果 X X X 完全决定 Y Y Y，则 H ( Y ∣ X ) = 0 H(Y|X)=0 H(Y∣X)=0；如果 X X X 与 Y Y Y 独立，则 H ( Y ∣ X ) = H ( Y ) H(Y|X)=H(Y) H(Y∣X)=H(Y)。

2.4 互信息（Mutual Information）

互信息是信息论中最重要的度量之一，用于衡量两个随机变量之间的相关性（非线性相关，优于皮尔逊相关系数）。

定义

I ( X ; Y ) = H ( X ) + H ( Y ) − H ( X , Y ) I(X;Y) = H(X) + H(Y) - H(X,Y) I(X;Y)=H(X)+H(Y)−H(X,Y)

等价公式：
I ( X ; Y ) = H ( X ) − H ( X ∣ Y ) = H ( Y ) − H ( Y ∣ X ) I(X;Y) = H(X) - H(X|Y) = H(Y) - H(Y|X) I(X;Y)=H(X)−H(X∣Y)=H(Y)−H(Y∣X)

核心性质

非负性： I ( X ; Y ) ≥ 0 I(X;Y) \geq 0 I(X;Y)≥0；
对称性： I ( X ; Y ) = I ( Y ; X ) I(X;Y)=I(Y;X) I(X;Y)=I(Y;X)；
独立变量： I ( X ; Y ) = 0 I(X;Y)=0 I(X;Y)=0；
完全相关： I ( X ; Y ) = H ( X ) = H ( Y ) I(X;Y)=H(X)=H(Y) I(X;Y)=H(X)=H(Y)。

互信息越大，两个变量的相关性越强；互信息为0，两个变量完全独立。在机器学习中，互信息常用于特征选择：筛选与标签相关性最高的特征。

2.5 相对熵（KL散度）

相对熵又称KL散度，用于衡量两个概率分布 P P P 和 Q Q Q 之间的差异。

定义

D K L ( P ∣ ∣ Q ) = ∑ x P ( x ) log ⁡ 2 P ( x ) Q ( x ) D_{KL}(P||Q) = \sum_{x} P(x) \log_2 \frac{P(x)}{Q(x)} DKL(P∣∣Q)=x∑P(x)log2Q(x)P(x)

核心性质

非负性： D K L ( P ∣ ∣ Q ) ≥ 0 D_{KL}(P||Q) \geq 0 DKL(P∣∣Q)≥0，当且仅当 P = Q P=Q P=Q 时取等号；
非对称性： D K L ( P ∣ ∣ Q ) ≠ D K L ( Q ∣ ∣ P ) D_{KL}(P||Q) \neq D_{KL}(Q||P) DKL(P∣∣Q)=DKL(Q∣∣P)；
无界性：取值可以无穷大。

KL散度不满足距离公式的对称性，因此不是真正的距离，但广泛用于分布对齐、模型优化、异常检测。

2.6 交叉熵（Cross Entropy）

交叉熵是深度学习、分类任务中最核心的损失函数 ，结合了真实分布 P P P 和预测分布 Q Q Q。

定义

H ( P , Q ) = − ∑ x P ( x ) log ⁡ 2 Q ( x ) H(P,Q) = -\sum_{x} P(x) \log_2 Q(x) H(P,Q)=−x∑P(x)log2Q(x)

核心关系

交叉熵 = 熵 + KL散度：
H ( P , Q ) = H ( P ) + D K L ( P ∣ ∣ Q ) H(P,Q) = H(P) + D_{KL}(P||Q) H(P,Q)=H(P)+DKL(P∣∣Q)

当真实分布 P P P 固定时，最小化交叉熵等价于最小化KL散度，这就是交叉熵作为损失函数的原因。

在二分类任务中，交叉熵公式简化为：
H ( P , Q ) = − y log ⁡ 2 ( y ^ ) − ( 1 − y ) log ⁡ 2 ( 1 − y ^ ) H(P,Q) = -y\log_2(\hat{y}) - (1-y)\log_2(1-\hat{y}) H(P,Q)=−ylog2(y^)−(1−y)log2(1−y^)

其中 y y y 是真实标签， y ^ \hat{y} y^ 是模型预测概率。

2.7 信息增益与信息增益比

信息增益是决策树算法（ID3）的核心划分标准，用于衡量特征 X X X 能减少标签 Y Y Y 多少不确定性。

定义

G a i n ( Y , X ) = H ( Y ) − H ( Y ∣ X ) = I ( X ; Y ) Gain(Y,X) = H(Y) - H(Y|X) = I(X;Y) Gain(Y,X)=H(Y)−H(Y∣X)=I(X;Y)

信息增益等价于互信息，值越大，特征的分类能力越强。

信息增益比（C4.5算法）解决了信息增益偏向取值多的特征的问题：
G a i n R a t i o ( Y , X ) = G a i n ( Y , X ) H ( X ) GainRatio(Y,X) = \frac{Gain(Y,X)}{H(X)} GainRatio(Y,X)=H(X)Gain(Y,X)

第三部分：C++ 信息论核心代码实现

本模块所有代码为纯C++原生实现，无第三方依赖，适配所有编译器，函数封装清晰，可直接调用。

3.1 基础工具函数

cpp 复制代码

#include <iostream>
#include <vector>
#include <cmath>
#include <unordered_map>
#include <algorithm>
#include <iomanip>
#include <string>
#include <stdexcept>

using namespace std;

// 全局常量：极小值（防止对数计算除零/对数零）
const double EPS = 1e-12;
// 对数转换常数：log2(x) = ln(x)/ln(2)
const double LOG2_CONST = log(2.0);

/**
 * @brief 计算以2为底的对数
 * @param x 输入值
 * @return log2(x)，x<=EPS时返回0
 */
inline double log2(double x) {
    if (x <= EPS) return 0.0;
    return log(x) / LOG2_CONST;
}

/**
 * @brief 将频数统计结果转换为概率分布
 * @param count 频数向量
 * @return 概率向量（和为1）
 */
vector<double> count_to_probability(const vector<int>& count) {
    vector<double> prob;
    int total = 0;
    // 计算总频数
    for (int num : count) {
        total += num;
    }
    if (total == 0) return prob;
    // 转换为概率
    for (int num : count) {
        prob.push_back(static_cast<double>(num) / total);
    }
    return prob;
}

/**
 * @brief 计算二维联合频数转联合概率
 * @param joint_count 联合频数字典
 * @param x_size 变量X的取值数
 * @param y_size 变量Y的取值数
 * @return 联合概率矩阵
 */
vector<vector<double>> joint_count_to_prob(const unordered_map<int, unordered_map<int, int>>& joint_count,
                                         int x_size, int y_size, int total) {
    vector<vector<double>> prob(x_size, vector<double>(y_size, 0.0));
    for (auto& x_item : joint_count) {
        int x = x_item.first;
        for (auto& y_item : x_item.second) {
            int y = y_item.first;
            prob[x][y] = static_cast<double>(y_item.second) / total;
        }
    }
    return prob;
}

3.2 自信息与香农熵实现

cpp 复制代码

/**
 * @brief 计算单个事件的自信息
 * @param probability 事件概率
 * @return 自信息（比特）
 */
double self_information(double probability) {
    if (probability < EPS || probability > 1.0 + EPS) return 0.0;
    return -log2(probability);
}

/**
 * @brief 计算离散随机变量的香农熵
 * @param probability 概率分布向量
 * @return 香农熵（比特）
 */
double shannon_entropy(const vector<double>& probability) {
    double entropy = 0.0;
    for (double p : probability) {
        if (p > EPS) {
            entropy -= p * log2(p);
        }
    }
    return entropy;
}

/**
 * @brief 从频数直接计算香农熵
 * @param count 频数向量
 * @return 香农熵
 */
double entropy_from_count(const vector<int>& count) {
    vector<double> prob = count_to_probability(count);
    return shannon_entropy(prob);
}

3.3 联合熵与条件熵实现

cpp 复制代码

/**
 * @brief 计算联合熵
 * @param joint_prob 联合概率矩阵
 * @return 联合熵 H(X,Y)
 */
double joint_entropy(const vector<vector<double>>& joint_prob) {
    double h = 0.0;
    for (const auto& row : joint_prob) {
        for (double p : row) {
            if (p > EPS) {
                h -= p * log2(p);
            }
        }
    }
    return h;
}

/**
 * @brief 计算X的边缘概率
 * @param joint_prob 联合概率矩阵
 * @return X的边缘概率
 */
vector<double> marginal_x(const vector<vector<double>>& joint_prob) {
    vector<double> res(joint_prob.size(), 0.0);
    for (int i = 0; i < joint_prob.size(); ++i) {
        for (double p : joint_prob[i]) {
            res[i] += p;
        }
    }
    return res;
}

/**
 * @brief 计算Y的边缘概率
 * @param joint_prob 联合概率矩阵
 * @return Y的边缘概率
 */
vector<double> marginal_y(const vector<vector<double>>& joint_prob) {
    if (joint_prob.empty()) return {};
    vector<double> res(joint_prob[0].size(), 0.0);
    for (const auto& row : joint_prob) {
        for (int j = 0; j < row.size(); ++j) {
            res[j] += row[j];
        }
    }
    return res;
}

/**
 * @brief 计算条件熵 H(Y|X)
 * @param joint_prob 联合概率矩阵
 * @return 条件熵
 */
double conditional_entropy(const vector<vector<double>>& joint_prob) {
    double h_xy = joint_entropy(joint_prob);
    double h_x = shannon_entropy(marginal_x(joint_prob));
    return h_xy - h_x;
}

3.4 互信息实现

cpp 复制代码

/**
 * @brief 计算两个随机变量的互信息
 * @param joint_prob 联合概率矩阵
 * @return 互信息 I(X;Y)
 */
double mutual_information(const vector<vector<double>>& joint_prob) {
    double h_x = shannon_entropy(marginal_x(joint_prob));
    double h_y = shannon_entropy(marginal_y(joint_prob));
    double h_xy = joint_entropy(joint_prob);
    return h_x + h_y - h_xy;
}

/**
 * @brief 从原始数据计算互信息（机器学习特征选择用）
 * @param feature 特征向量
 * @param label 标签向量
 * @return 互信息值
 */
double mutual_information_from_data(const vector<int>& feature, const vector<int>& label) {
    if (feature.size() != label.size()) {
        throw invalid_argument("特征与标签长度不一致！");
    }
    int total = feature.size();
    unordered_map<int, int> feat_count, label_count;
    unordered_map<int, unordered_map<int, int>> joint_count;

    // 统计频数
    for (int i = 0; i < total; ++i) {
        int f = feature[i];
        int l = label[i];
        feat_count[f]++;
        label_count[l]++;
        joint_count[f][l]++;
    }

    // 转换为联合概率
    int x_size = feat_count.size();
    int y_size = label_count.size();
    vector<vector<double>> joint_prob = joint_count_to_prob(joint_count, x_size, y_size, total);

    return mutual_information(joint_prob);
}

3.5 KL散度与交叉熵实现

cpp 复制代码

/**
 * @brief 计算KL散度 D_KL(P||Q)
 * @param P 真实概率分布
 * @param Q 预测概率分布
 * @return KL散度值
 */
double kl_divergence(const vector<double>& P, const vector<double>& Q) {
    if (P.size() != Q.size()) {
        throw invalid_argument("两个分布维度不一致！");
    }
    double divergence = 0.0;
    for (int i = 0; i < P.size(); ++i) {
        double p = P[i];
        double q = Q[i];
        if (p < EPS) continue;
        if (q < EPS) return 1e18; // 避免除零
        divergence += p * log2(p / q);
    }
    return divergence;
}

/**
 * @brief 计算交叉熵 H(P,Q)
 * @param P 真实分布
 * @param Q 预测分布
 * @return 交叉熵值
 */
double cross_entropy(const vector<double>& P, const vector<double>& Q) {
    if (P.size() != Q.size()) {
        throw invalid_argument("两个分布维度不一致！");
    }
    double ce = 0.0;
    for (int i = 0; i < P.size(); ++i) {
        double p = P[i];
        double q = Q[i];
        if (p < EPS) continue;
        if (q < EPS) return 1e18;
        ce -= p * log2(q);
    }
    return ce;
}

/**
 * @brief 二分类交叉熵损失（深度学习专用）
 * @param y_true 真实标签（0或1）
 * @param y_pred 预测概率（0~1）
 * @return 二分类交叉熵
 */
double binary_cross_entropy(double y_true, double y_pred) {
    y_pred = max(EPS, min(1.0 - EPS, y_pred));
    return -(y_true * log2(y_pred) + (1.0 - y_true) * log2(1.0 - y_pred));
}

/**
 * @brief 多分类交叉熵损失
 * @param y_true 真实标签one-hot向量
 * @param y_pred 预测概率向量
 * @return 多分类交叉熵
 */
double multi_cross_entropy(const vector<double>& y_true, const vector<double>& y_pred) {
    return cross_entropy(y_true, y_pred);
}

3.6 文本熵计算实现

cpp 复制代码

/**
 * @brief 计算文本的字符熵（用于文本分类、加密检测）
 * @param text 输入文本字符串
 * @return 文本字符熵
 */
double text_char_entropy(const string& text) {
    unordered_map<char, int> char_count;
    // 统计字符频数
    for (char c : text) {
        char_count[c]++;
    }
    // 转换为频数向量
    vector<int> count;
    for (auto& item : char_count) {
        count.push_back(item.second);
    }
    return entropy_from_count(count);
}

/**
 * @brief 计算文本的单词熵
 * @param text 文本字符串
 * @param delimiter 分隔符
 * @return 单词熵
 */
double text_word_entropy(const string& text, char delimiter = ' ') {
    unordered_map<string, int> word_count;
    string word;
    for (char c : text) {
        if (c == delimiter) {
            if (!word.empty()) {
                word_count[word]++;
                word.clear();
            }
        } else {
            word += c;
        }
    }
    if (!word.empty()) word_count[word]++;

    vector<int> count;
    for (auto& item : word_count) {
        count.push_back(item.second);
    }
    return entropy_from_count(count);
}

3.7 信息增益实现

cpp 复制代码

/**
 * @brief 计算信息增益
 * @param label_entropy 标签的熵 H(Y)
 * @param conditional_entropy 条件熵 H(Y|X)
 * @return 信息增益
 */
double information_gain(double label_entropy, double conditional_entropy) {
    return label_entropy - conditional_entropy;
}

/**
 * @brief 计算信息增益比
 * @param info_gain 信息增益
 * @param feature_entropy 特征的熵 H(X)
 * @return 信息增益比
 */
double information_gain_ratio(double info_gain, double feature_entropy) {
    if (feature_entropy < EPS) return 0.0;
    return info_gain / feature_entropy;
}

第四部分：完整可运行C++信息论工具库

4.1 全模块整合代码

cpp 复制代码

// 完整信息论C++工具库
#include <iostream>
#include <vector>
#include <cmath>
#include <unordered_map>
#include <algorithm>
#include <iomanip>
#include <string>
#include <stdexcept>

using namespace std;

const double EPS = 1e-12;
const double LOG2_CONST = log(2.0);

inline double log2(double x) {
    return (x <= EPS) ? 0.0 : log(x) / LOG2_CONST;
}

vector<double> count_to_probability(const vector<int>& count) {
    vector<double> prob;
    int total = 0;
    for (int num : count) total += num;
    if (total == 0) return prob;
    for (int num : count) prob.push_back(static_cast<double>(num)/total);
    return prob;
}

double self_information(double probability) {
    return (probability<EPS||probability>1.0+EPS) ? 0.0 : -log2(probability);
}

double shannon_entropy(const vector<double>& prob) {
    double h = 0.0;
    for (double p : prob) if (p>EPS) h -= p*log2(p);
    return h;
}

double entropy_from_count(const vector<int>& count) {
    return shannon_entropy(count_to_probability(count));
}

double joint_entropy(const vector<vector<double>>& joint_prob) {
    double h = 0.0;
    for (auto& r : joint_prob) for (double p : r) if (p>EPS) h -= p*log2(p);
    return h;
}

vector<double> marginal_x(const vector<vector<double>>& jp) {
    vector<double> res(jp.size(),0);
    for(int i=0;i<jp.size();i++) for(double p:jp[i]) res[i]+=p;
    return res;
}

vector<double> marginal_y(const vector<vector<double>>& jp) {
    if(jp.empty()) return {};
    vector<double> res(jp[0].size(),0);
    for(auto& r:jp) for(int j=0;j<r.size();j++) res[j]+=r[j];
    return res;
}

double conditional_entropy(const vector<vector<double>>& jp) {
    return joint_entropy(jp) - shannon_entropy(marginal_x(jp));
}

double mutual_information(const vector<vector<double>>& jp) {
    return shannon_entropy(marginal_x(jp)) + shannon_entropy(marginal_y(jp)) - joint_entropy(jp);
}

double kl_divergence(const vector<double>& P, const vector<double>& Q) {
    double d=0;
    for(int i=0;i<P.size();i++){
        if(P[i]<EPS) continue;
        if(Q[i]<EPS) return 1e18;
        d += P[i]*log2(P[i]/Q[i]);
    }
    return d;
}

double cross_entropy(const vector<double>& P, const vector<double>& Q) {
    double ce=0;
    for(int i=0;i<P.size();i++){
        if(P[i]<EPS) continue;
        if(Q[i]<EPS) return 1e18;
        ce -= P[i]*log2(Q[i]);
    }
    return ce;
}

double binary_cross_entropy(double y, double p) {
    p = max(EPS, min(1-EPS, p));
    return -(y*log2(p) + (1-y)*log2(1-p));
}

double text_char_entropy(const string& s) {
    unordered_map<char,int> cnt;
    for(char c:s) cnt[c]++;
    vector<int> count;
    for(auto& p:cnt) count.push_back(p.second);
    return entropy_from_count(count);
}

// 主函数测试
int main() {
    cout << fixed << setprecision(6);
    cout << "========== C++ 信息论工具库测试 ==========" << endl;

    // 1. 自信息测试
    cout << "概率0.5的自信息：" << self_information(0.5) << " 比特" << endl;

    // 2. 香农熵测试
    vector<int> count = {2,2}; // 抛硬币
    cout << "均匀硬币熵：" << entropy_from_count(count) << endl;

    // 3. 文本熵测试
    string text = "aaaaabbbbbcccccdddddeeeee";
    cout << "文本字符熵：" << text_char_entropy(text) << endl;

    // 4. 交叉熵测试
    vector<double> P = {0.5,0.5};
    vector<double> Q = {0.1,0.9};
    cout << "交叉熵：" << cross_entropy(P,Q) << endl;

    // 5. 二分类交叉熵
    cout << "二分类交叉熵(y=1,pred=0.8)：" << binary_cross_entropy(1,0.8) << endl;

    return 0;
}

4.2 运行说明

编译命令：g++ information_theory.cpp -o it -std=c++11
运行命令：./it
输出结果：所有核心函数的测试结果，精度保留6位小数。

第五部分：信息论高级定理与应用

5.1 香农三大定理

香农第一定理（信源编码定理）

离散无记忆信源的最优无损压缩码长的极限等于信源的香农熵。任何压缩算法都无法将平均码长压缩到熵以下，这是数据压缩的理论天花板。

香农第二定理（信道编码定理）

在有噪声的信道中，存在一个最大传输速率（信道容量 ），当传输速率小于信道容量时，信息可以无差错传输；大于信道容量时，无法保证无差错传输。信道容量公式：
C = B log ⁡ 2 ( 1 + S / N ) C = B\log_2(1+S/N) C=Blog2(1+S/N)

其中 B B B 是带宽， S / N S/N S/N 是信噪比。

香农第三定理（保真度准则下的信源编码定理）

允许一定失真时，信源可以被更大程度压缩，压缩极限由率失真函数决定。

5.2 数据压缩极限

根据香农第一定理，文本、图像、音频的最优压缩比 = 熵 / 原始码长。例如：英文文本熵约为1.5比特/字符，ASCII编码每个字符8比特，理论压缩比可达5.3倍。

5.3 最大熵原理

在未知概率分布时，应选择熵最大的分布，这是最无偏、最客观的选择。例如：无先验信息时，均匀分布是最优选择。

第六部分：信息论工程实践

6.1 文本加密检测

加密文本的字符熵远高于普通文本，因为加密后字符分布均匀。通过计算文本熵，可以快速判断文本是否被加密。

6.2 数据压缩率评估

计算文件熵，即可得到理论最小压缩大小，评估当前压缩算法的效率。

6.3 机器学习特征筛选

计算特征与标签的互信息，保留互信息高的特征，删除冗余特征，提升模型训练速度与精度。

全文总结

教程包含自信息、香农熵、联合熵、条件熵、互信息、KL散度、交叉熵、信息增益 八大核心度量，搭配文本熵计算、深度学习损失函数、特征选择三大工程应用，同时讲解香农三大定理、数据压缩极限、信道容量等高级理论，是学习、竞赛、工程开发的完整资料。

C++信息论超详解析

目录

C++ 信息论完整教程（纯文字+代码合计）

前言

目录

第一部分：信息论基础理论

第二部分：信息论核心度量

第三部分：C++ 信息论核心代码实现（约4500字）

第四部分：完整可运行C++信息论工具库

第五部分：信息论高级定理与应用

第六部分：信息论工程实践

第一部分：信息论基础理论

1.1 信息的定义与量化

1.2 自信息（Self-Information）

定义

单位

核心性质

1.3 概率分布与离散随机变量

1.4 信息论的核心研究对象

1.5 信息论的应用领域

第二部分：信息论核心度量

2.1 香农熵（Shannon Entropy）

定义

物理意义

举例

2.2 联合熵（Joint Entropy）

定义

核心性质

2.3 条件熵（Conditional Entropy）

定义

物理意义

2.4 互信息（Mutual Information）

定义

核心性质

2.5 相对熵（KL散度）

定义

核心性质

2.6 交叉熵（Cross Entropy）

定义

核心关系

2.7 信息增益与信息增益比

定义

第三部分：C++ 信息论核心代码实现

3.1 基础工具函数

3.2 自信息与香农熵实现

3.3 联合熵与条件熵实现

3.4 互信息实现

3.5 KL散度与交叉熵实现

3.6 文本熵计算实现

3.7 信息增益实现

第四部分：完整可运行C++信息论工具库

4.1 全模块整合代码

4.2 运行说明

第五部分：信息论高级定理与应用

5.1 香农三大定理

香农第一定理（信源编码定理）

香农第二定理（信道编码定理）

香农第三定理（保真度准则下的信源编码定理）

5.2 数据压缩极限

5.3 最大熵原理

第六部分：信息论工程实践

6.1 文本加密检测

6.2 数据压缩率评估

6.3 机器学习特征筛选

全文总结