39、C++项目实战：区块链模拟（工作量证明）

说实话，区块链这个概念前几年火得一塌糊涂。很多人一听到区块链，就想到比特币、挖矿、去中心化这些词。但作为一个C++工程师，我更关心的是：这东西到底怎么用代码实现？

今天我们就来手写一个简化版的区块链模拟器，核心是工作量证明（Proof of Work，PoW）。别被名字吓到，说白了就是“谁先算出来，谁说了算”。

区块链的核心结构

先聊聊区块链的本质。它其实就是一个链表，只不过每个节点（区块）里存的是交易数据，而且每个区块都通过哈希值链接到前一个区块。

我当年第一次接触区块链时，第一反应是：“这不就是链表加哈希吗？” 嗯，确实如此。但难点在于，如何保证这个链表不被篡改？答案就是工作量证明。

区块的数据结构

我们先定义区块长什么样。每个区块需要包含：

• 索引：区块在链中的位置
• 时间戳：生成时间
• 交易数据：可以简单用字符串表示
• 前一个区块的哈希：这是链的关键
• 当前区块的哈希：由区块内容计算得出
• Nonce：工作量证明要找的那个数

struct Block {
    int index;
    std::string data;
    std::string prevHash;
    std::string hash;
    time_t timestamp;
    int nonce;

    Block(int idx, const std::string& d, const std::string& prev)
        : index(idx), data(d), prevHash(prev), nonce(0) {
        timestamp = std::time(nullptr);
        hash = calculateHash();
    }

    std::string calculateHash() const {
        std::stringstream ss;
        ss << index << timestamp << data << prevHash << nonce;
        return sha256(ss.str());  // 假设有sha256函数
    }
};

这里有个细节：calculateHash() 把 nonce 也纳入了计算。为什么？因为我们要通过调整 nonce 来改变哈希值，直到它满足某个条件。

工作量证明：到底在证明什么？

工作量证明的核心思想很简单：你要找到一个 nonce，使得区块的哈希值以特定数量的零开头。

比如，我们要求哈希值以4个零开头（即难度为4）。那么你就得不断尝试不同的 nonce，直到算出来的哈希满足条件。

我曾经在优化这个算法时踩过一个坑：直接用 int 累加 nonce，结果在32位系统上溢出了。后来我改成了 uint64_t，才稳定下来。

void mineBlock(int difficulty) {
    std::string target(difficulty, '0');  // 目标前缀
    while (hash.substr(0, difficulty) != target) {
        nonce++;
        hash = calculateHash();
    }
    std::cout << "区块已挖出! nonce = " << nonce << std::endl;
}

你看，代码其实没几行。但就是这个简单的循环，构成了比特币“挖矿”的本质——暴力计算。

区块链的验证机制

有了区块和挖矿逻辑，接下来就是链本身。区块链需要保证：

1. 每个区块的 prevHash 必须等于前一个区块的 hash
2. 每个区块的哈希必须满足难度要求
3. 整个链不能有断裂

class Blockchain {
private:
    std::vector<Block> chain;
    int difficulty;

public:
    Blockchain(int diff) : difficulty(diff) {
        chain.emplace_back(Block(0, "创世区块", "0"));
    }

    void addBlock(const std::string& data) {
        Block newBlock(chain.size(), data, chain.back().hash);
        newBlock.mineBlock(difficulty);
        chain.push_back(newBlock);
    }

    bool isChainValid() const {
        for (size_t i = 1; i < chain.size(); i++) {
            const Block& current = chain[i];
            const Block& previous = chain[i - 1];

            if (current.hash != current.calculateHash()) return false;
            if (current.prevHash != previous.hash) return false;
        }
        return true;
    }
};

这里我特别想强调一点：验证时一定要重新计算哈希。你不能直接信任区块里存的 hash 字段，因为那可能是伪造的。我在项目中就遇到过有人试图篡改交易数据，然后手动改掉 hash 字段来蒙混过关。重新计算哈希就能发现这种作弊行为。

核心流程图

下面这张图展示了区块链模拟的核心流程，从创建区块到验证整个链：

难度与性能的权衡

工作量证明有个很现实的问题：难度越高，挖矿越慢。在真实场景中，比特币的难度会动态调整，保证平均10分钟出一个块。

我们的模拟器里，你可以手动设置难度。我建议从3开始试，如果设到6以上，你可能会等得有点不耐烦。

难度值	目标前缀	平均尝试次数	适用场景
3	"000"	~4096	快速测试
4	"0000"	~65536	教学演示
5	"00000"	~1048576	压力测试
6	"000000"	~16777216	接近真实场景

完整代码示例

下面是一个可运行的完整示例，包含了 SHA-256 的简化实现（实际项目中请用 OpenSSL 或 Crypto++）：

#include <iostream>
#include <vector>
#include <sstream>
#include <ctime>
#include <iomanip>

// 简化的SHA256（实际请用库）
std::string sha256(const std::string& str) {
    // 这里用伪哈希演示，真实项目替换为OpenSSL
    std::hash<std::string> hasher;
    auto hash = hasher(str);
    std::stringstream ss;
    ss << std::hex << hash;
    return ss.str();
}

struct Block {
    int index;
    std::string data;
    std::string prevHash;
    std::string hash;
    time_t timestamp;
    uint64_t nonce;

    Block(int idx, const std::string& d, const std::string& prev)
        : index(idx), data(d), prevHash(prev), nonce(0) {
        timestamp = std::time(nullptr);
        hash = calculateHash();
    }

    std::string calculateHash() const {
        std::stringstream ss;
        ss << index << timestamp << data << prevHash << nonce;
        return sha256(ss.str());
    }

    void mineBlock(int difficulty) {
        std::string target(difficulty, '0');
        while (hash.substr(0, difficulty) != target) {
            nonce++;
            hash = calculateHash();
        }
        std::cout << "区块 " << index << " 挖矿完成，nonce = " << nonce << std::endl;
    }
};

class Blockchain {
private:
    std::vector<Block> chain;
    int difficulty;

public:
    Blockchain(int diff) : difficulty(diff) {
        chain.emplace_back(Block(0, "创世区块", "0"));
    }

    void addBlock(const std::string& data) {
        Block newBlock(chain.size(), data, chain.back().hash);
        newBlock.mineBlock(difficulty);
        chain.push_back(newBlock);
    }

    bool isChainValid() const {
        for (size_t i = 1; i < chain.size(); i++) {
            const Block& current = chain[i];
            const Block& previous = chain[i - 1];
            if (current.hash != current.calculateHash()) return false;
            if (current.prevHash != previous.hash) return false;
        }
        return true;
    }

    void printChain() const {
        for (const auto& block : chain) {
            std::cout << "索引: " << block.index
                      << " | 数据: " << block.data
                      << " | 哈希: " << block.hash.substr(0, 10) << "..."
                      << " | nonce: " << block.nonce << std::endl;
        }
    }
};

int main() {
    Blockchain bc(4);  // 难度4

    bc.addBlock("转账 10 BTC 给 Alice");
    bc.addBlock("转账 5 BTC 给 Bob");
    bc.addBlock("转账 2 BTC 给 Charlie");

    std::cout << "\n区块链状态:" << std::endl;
    bc.printChain();

    std::cout << "\n链是否有效? " << (bc.isChainValid() ? "是" : "否") << std::endl;
    return 0;
}

避坑指南

最后分享几个我踩过的坑：

• 哈希计算要包含 nonce：我曾经忘了把 nonce 放进哈希计算，结果怎么挖都挖不出来——因为哈希根本不变。
• 时间戳用 time_t 而不是 int：32位 int 在2038年会溢出，虽然我们模拟器用不到那么久，但养成好习惯。
• 验证链时一定要重新计算哈希：不要相信区块里存的 hash 字段，那是可以被篡改的。
• 难度不要设太高：教学演示设4就够了，设到6以上你可能要等几分钟。

好了，这就是区块链模拟的核心实现。你想想看，其实核心逻辑就那么几行代码，但背后蕴含的思想——去中心化、不可篡改、工作量证明——才是真正有价值的东西。

如果你在实际项目中需要用到区块链，建议直接使用成熟的库，比如 libbitcoin 或 cpp-ethereum。自己手写只是为了理解原理，生产环境还是要用经过验证的方案。