Раскодировка двоичного файла

    void decifer(const char *from, const char *where)
    {
        std::ifstream in(from, std::ios_base::binary | std::ios_base::in);
        std::ofstream out(where, std::ios_base::binary | std::ios_base::out);
        haffman_node *p = start;
        char count = 0;
        char byte;
        bool bit;
        byte = in.get();
        while(!in.eof())
        {
            bit = byte & (1 << (7 - count));
            if(bit)
                p = p->left;
            else
                p = p->right;
            if(p->symbol != '\0')
            {
                out << p->symbol;
                p = start;
            }
            ++count;
            if(count = 8)
            {
                count = 0;
                byte = in.get();
            }
        }
        in.close();
        out.close();
    }

#include <fstream>
#include <iostream>
#include <map>
#include <string>
 
class haffman
{
    struct haffman_node
    {
        haffman_node *left;
        haffman_node *right;
        char symbol;
        float val;
    };
 
private:
    std::multimap<float, haffman_node*> node_map;
    std::multimap<float, haffman_node*>::iterator it_node_map;
    std::map<char, std::string> symbol_code_map;
    std::map<char, std::string>::iterator it_symbol_code_map;
    std::string text;
    haffman_node *start;
    const int size = 256;
    char *chr;
    float *freq;
    int *symbol;
    int diff_symbol;
 
    void count_freq_of_symbol()
    {
        int len = text.size();
        int j = 0;
        for (int i = 0; i < size; ++i)
        {
            symbol[i] = 0;
            freq[i] = 0;
            chr[i] = 0;
        }
        for (int i = 0; i < len; ++i)
            symbol[+text[i]]++;
        for (int i = 0; i < size; ++i)
        {
            if (symbol[i])
                diff_symbol++;
        }
        for (int i = 0; i < size; ++i)
        {
            if (symbol[i])
            {
                chr[j] = char(i);
                freq[j++] = (float)symbol[i] / len;
            }
        }
    }
 
    void build_first_node()
    {
        for (int i = 0; i < diff_symbol; ++i)
        {
            haffman_node *hn = new haffman_node;
            fill_node(hn, freq[i], chr[i]);
            node_map.insert(std::pair<float, haffman_node*>(freq[i], hn));
        }
        build_tree();
    }
 
    void fill_node(haffman_node *&node, const float num, const char ch, haffman_node *l = NULL, haffman_node *r = NULL)
    {
        node->left = l;
        node->right = r;
        node->val = num;
        node->symbol = ch;
    }
 
    void get_data(float &num, haffman_node *&hf)
    {
        it_node_map = node_map.begin();
        num = it_node_map->first;
        hf = it_node_map->second;
        node_map.erase(it_node_map);
    }
 
    void build_tree()
    {
        haffman_node *hf1, *hf2;
        float x, y;
        for (int i = 1; i <= diff_symbol - 1; ++i)
        {
            haffman_node *HF = new haffman_node;
 
            get_data(x, hf1);
            get_data(y, hf2);
 
            fill_node(HF, x + y, '\0', hf1, hf2);
            node_map.insert(std::pair<float, haffman_node*>(x + y, HF));
        }
        it_node_map = node_map.begin();
        start = it_node_map->second;
    }
 
    void code_of_symbol(haffman_node *node, std::string code)
    {
        if (node != NULL)
        {
            if (node->symbol != '\0')
                symbol_code_map.insert(std::pair<char, std::string>(node->symbol, code));
            code_of_symbol(node->left, code + '0');
            code_of_symbol(node->right, code + '1');
        }
    }
 
    void _codify(const std::string &str, const char *filename)
    {
        std::ofstream out(filename, std::ios_base::binary | std::ios_base::out);
        char byte = 0;
        char count = 0;
        for(int i = 0; i < str.size(); ++i)
        {
            it_symbol_code_map = symbol_code_map.find(str[i]);
            std::string code = it_symbol_code_map->second;
            //std::cout << code << std::endl;
            for(int j = 0; j < code.size(); ++j)
            {
                char bit = +code[j] - 48;
                byte = byte | (bit << (7 - count));
                ++count;
                if(count == 8)
                {
                    count = 0;
                    out << byte;
                    byte = 0;
                }
            }
        }
        if(count > 0)
            out << byte;
        out.close();
    }
 
public:
    haffman()
    {
        start = NULL;
        symbol = new int[size];
        freq = new float[size];
        chr = new char[size];
    }
 
    ~haffman()
    {
        delete[] symbol, freq, chr;
    }
 
    void codify(const std::string &str, const char *filename)
    {
        node_map.clear();
        symbol_code_map.clear();
        diff_symbol = 0;
        text = str;
        count_freq_of_symbol();
        build_first_node();
        code_of_symbol(start, "");
        _codify(str, filename);
    }
 
    void decifer(const char *from, const char *where)
    {
        std::ifstream in(from, std::ios_base::binary | std::ios_base::in);
        std::ofstream out(where, std::ios_base::binary | std::ios_base::out);
        haffman_node *p = start;
        char count = 0;
        char byte;
        bool bit;
        byte = in.get();
        while(!in.eof())
        {
            bit = byte & (1 << (7 - count));
            if(bit)
                p = p->left;
            else
                p = p->right;
            if(p->symbol != '\0')
            {
                out << p->symbol;
                p = start;
            }
            ++count;
            if(count = 8)
            {
                count = 0;
                byte = in.get();
            }
        }
        in.close();
        out.close();
    }
};
 
int main()
{
    setlocale(LC_ALL, "rus");
    std::ifstream in_first("c:\\input.txt");
    std::string str_first;
    haffman ob;
    std::getline(in_first, str_first);
    in_first.close();
 
    ob.codify("AAABKKOO", "c:\\binary1.bin");
    ob.decifer("c:\\binary1.bin", "c:\\binary2.bin");
 
}