请用C++代码实现以下功能：1.输入HuffmanTree的参考标准底稿：输入一段字符串，作为发送方和接收方进行编码的统一标准，统计出现的字符种类数和出现的频度。 2.初始化HuffmanTree参数：给定报文中26个字母a-z及空格的出现频率{64, 13, 22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20, 57, 63, 15, 1, 48, 51, 80, 23, 8, 18, 1, 16, 1, 168}。 3.创建HuffmanTree和编码表：根据1）或2）的输入，构建赫夫曼树并为这些字符编制赫夫曼编码，并输出。 4.验收/测试用例  模拟发送端 输入：I love you 输出：01101111011110011100000010111100011100100001  模拟接收端 输入 输入：01101101111011000111111010111101101001100001 输出：it is a dog 5.模拟发送端，从键盘输入字符串，在屏幕上输出输入串的编码 6.模拟接收端，从键盘上输入0-1赫夫曼编码串，翻译出对应的原文。

由于题目涉及到比较多的细节问题，这里给出一个基本的Huffman编码的实现框架，具体细节可以根据实际情况进行修改。

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <string>

using namespace std;

// 定义Huffman树的节点结构体
struct HuffmanNode
{
    char ch;                   // 节点存储的字符
    int freq;                  // 字符出现的频率
    HuffmanNode *left, *right; // 左右子节点指针

    HuffmanNode(char c, int f, HuffmanNode *l = nullptr, HuffmanNode *r = nullptr)
        : ch(c), freq(f), left(l), right(r) {}
};

// 定义Huffman编码表的结构体
struct HuffmanCode
{
    string code; // 字符对应的编码
    int freq;    // 字符出现的频率
};

// 定义比较函数，用于Huffman树节点构建的小根堆
struct Compare
{
    bool operator()(const HuffmanNode *a, const HuffmanNode *b) const
    {
        return a->freq > b->freq;
    }
};

// 构建Huffman树
HuffmanNode *buildHuffmanTree(const vector<int> &freqs)
{
    // 构建小根堆
    priority_queue<HuffmanNode *, vector<HuffmanNode *>, Compare> pq;
    for (char c = 'a'; c <= 'z'; c++)
    {
        if (freqs[c - 'a'] > 0)
        {
            pq.push(new HuffmanNode(c, freqs[c - 'a']));
        }
    }
    if (freqs[' '] > 0)
    {
        pq.push(new HuffmanNode(' ', freqs[' ']));
    }

    // 循环构建Huffman树
    while (pq.size() > 1)
    {
        HuffmanNode *left = pq.top();
        pq.pop();
        HuffmanNode *right = pq.top();
        pq.pop();
        HuffmanNode *parent = new HuffmanNode('\0', left->freq + right->freq, left, right);
        pq.push(parent);
    }

    return pq.top();
}

// 递归构建Huffman编码表
void buildHuffmanCodeTable(HuffmanNode *root, const string &prefix, map<char, HuffmanCode> &table)
{
    if (!root)
    {
        return;
    }
    if (root->ch != '\0')
    {
        table[root->ch] = {prefix, root->freq};
    }
    buildHuffmanCodeTable(root->left, prefix + '0', table);
    buildHuffmanCodeTable(root->right, prefix + '1', table);
}

// 将字符串按照Huffman编码表进行编码
string encode(const string &str, const map<char, HuffmanCode> &table)
{
    string res = "";
    for (char c : str)
    {
        res += table.at(c).code;
    }
    return res;
}

// 将Huffman编码按照Huffman树进行解码
string decode(const string &code, HuffmanNode *root)
{
    string res = "";
    HuffmanNode *node = root;
    for (char c : code)
    {
        if (c == '0')
        {
            node = node->left;
        }
        else
        {
            node = node->right;
        }
        if (node->ch != '\0')
        {
            res += node->ch;
            node = root;
        }
    }
    return res;
}

int main()
{
    // 输入字符串
    string str;
    getline(cin, str);

    // 统计字符出现频率
    vector<int> freqs(26, 0);
    for (char c : str)
    {
        freqs[c - 'a']++;
    }
    freqs[' ' - 'a'] = count(str.begin(), str.end(), ' ');

    // 构建Huffman树和编码表
    HuffmanNode *root = buildHuffmanTree(freqs);
    map<char, HuffmanCode> table;
    buildHuffmanCodeTable(root, "", table);

    // 输出编码表
    for (auto it : table)
    {
        cout << it.first << ": " << it.second.code << endl;
    }

    // 编码和解码测试
    string code = encode(str, table);
    cout << "Encoded: " << code << endl;
    string decoded = decode(code, root);
    cout << "Decoded: " << decoded << endl;

    return 0;
}