办公室局域网监控中的C++布隆过滤器优化算法

#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <openssl/sha.h>  // 依赖OpenSSL库实现SHA-256哈希
// 优化版布隆过滤器类
class OptimizedBloomFilter {
private:
    std::vector<bool> bits;       // 二进制位数组
    uint64_t m;                   // 位数组长度
    uint32_t k;                   // 哈希函数个数
    // 哈希函数：基于SHA-256生成指定偏移的哈希值
    uint64_t sha256Hash(const std::string& data, uint32_t offset) const {
        unsigned char hash[SHA256_DIGEST_LENGTH];
        SHA256(reinterpret_cast<const unsigned char*>(data.c_str()), data.size(), hash);
        // 按偏移量取8字节计算哈希值，保证函数独立性
        uint64_t result = 0;
        for (int i = offset % 24; i < offset % 24 + 8; ++i) {
            result = (result << 8) | hash[i];
        }
        return result % m;
    }
    // 自定义偏移哈希函数
    uint64_t customHash(const std::string& data, uint32_t seed) const {
        uint64_t hash = seed;
        for (char c : data) {
            hash = (hash ^ (static_cast<uint64_t>(c))) * 1099511628211ULL;
        }
        return hash % m;
    }
public:
    // 构造函数：根据预期数据量n和误判率p初始化
    OptimizedBloomFilter(uint64_t n, double p) {
        if (p <= 0 || p >= 1) {
            throw std::invalid_argument("误判率需在(0,1)区间内");
        }
        m = static_cast<uint64_t>(ceil(-static_cast<double>(n) * log(p) / pow(log(2), 2)));
        k = static_cast<uint32_t>(ceil(static_cast<double>(m) * log(2) / static_cast<double>(n)));
        bits.resize(m, false);
    }
    // 插入数据
    void insert(const std::string& data) {
        for (uint32_t i = 0; i < k; ++i) {
            uint64_t idx1 = sha256Hash(data, i);
            uint64_t idx2 = customHash(data, i + 100);
            bits[idx1] = true;
            bits[idx2] = true;
        }
    }
    // 判断数据是否可能存在
    bool mightExist(const std::string& data) const {
        for (uint32_t i = 0; i < k; ++i) {
            uint64_t idx1 = sha256Hash(data, i);
            uint64_t idx2 = customHash(data, i + 100);
            if (!bits[idx1] || !bits[idx2]) {
                return false;
            }
        }
        return true;
    }
    // 办公室局域网监控IP校验接口
    bool checkLegalIP(const std::string& ip) const {
        return mightExist(ip);
    }
};
// 测试例程：模拟办公室局域网监控IP白名单校验
int main() {
    // 初始化：预期1000个合法IP，误判率0.001
    OptimizedBloomFilter bf(1000, 0.001);
    std::cout << "布隆过滤器初始化完成：位数组长度=" << bf.m << "，哈希函数对个数=" << bf.k << std::endl;
    // 模拟添加办公室合法设备IP
    std::vector<std::string> legalIPs = {
        "192.168.0.101", "192.168.0.102", "192.168.0.103",
        "192.168.0.104", "192.168.0.105", "192.168.0.106"
    };
    for (const auto& ip : legalIPs) {
        bf.insert(ip);
    }
    // 模拟办公室局域网监控接入校验场景
    std::vector<std::string> testIPs = {
        "192.168.0.101",  // 合法IP
        "192.168.0.201",  // 非法IP
        "192.168.0.107",  // 未录入的合法IP
        "192.168.0.103"   // 合法IP
    };
    for (const auto& ip : testIPs) {
        if (bf.checkLegalIP(ip)) {
            std::cout << "IP[" << ip << "] 疑似合法，进入数据库精准校验" << std::endl;
        } else {
            std::cout << "IP[" << ip << "] 非法，办公室局域网监控系统拒绝接入" << std::endl;
        }
    }
    return 0;
}