EXTSort

#include <iostream>
#include <vector>
#include <string>
#include <fstream>

using namespace std;

class CPairHeap{
    public:
    std::vector< pair<int, int> > storage;
    CPairHeap(){};
    ~CPairHeap(){ storage.clear(); }

    void add(pair <int, int> el){
        storage.push_back(el);
//        sift_up();
    }

    pair<int, int> get_min(){
        pair <int, int> ans = storage[0];
        swap(storage[0], storage[storage.size() - 1]);
        sift_down();
        return ans;
    }

    private:

    void sift_down(){
        int fin = storage.size() - 1;
        int root = 0;

        int child = 0;
        while((child = root * 2 + 1) <= fin){
            if(child + 1 <= fin && storage[child] < storage[child + 1])
                child++;
            if(storage[root] < storage[child]){
                swap(storage[root], storage[child]);
                root = child;
            }
            else{
                return;
            }
        }
    }
};

class CPriority_Queue{
    public:
    CPairHeap heap;
    CPriority_Queue(){}

    pair<int, int> get_min(){
        return heap.get_min();
    }

    void add(pair<int, int> el){
        heap.add(el);
    }
};

class CFileReader{ //reading file
    private:
    ifstream* input;

    public:
    CFileReader(string fname){ input = new ifstream(fname); }
    CFileReader();
    ~CFileReader(){ input->close(); }

    int get(){
        int a;
        *input >> a;
        return a;
    }

    bool can_read(){
        return !(input->eof());
    }
};

class CFileWriter{ //writing file
    private:
    ofstream* output;


    public:
    CFileWriter();
    CFileWriter(string fname){ output = new ofstream(fname); }
    ~CFileWriter(){ output->close();}

    void write(int n){
        *output << n;
    }
};

class CSortedListFromFile
{
    private:
    CFileReader input("inp.txt");
    size_t lim = 10000;
    vector <int> buff();
    string buff_prefix = "to_merge_";
    size_t files_num = 0;

    public:
    CSortedListFromFile();
    ~CSortedListFromFile();

    void write_sorted_buff(){
        CFileWriter writer(buff_prefix + files_num);
        for(size_t i = 0; i < buff.size(); i++){
            writer.write(buff[i]);
            writer.write('\n');
        }
        files_num++;
    }

    void process_input(){
        size_t i = 0;
        while(input.can_read()){
            if(i >= lim){
                merge_sort(buff);
                write_sorted_buff();
                clear(buff);
                i = 0;
            }
            buff.push_back(input.get());
            i++;
        }
    }

    void do_all_this_merge_stuff(){
        CPriority_Queue prior_q();
        vector <CFileReader()> streams;

        for(size_t i = 0; i < files_num; i++){
            streams.push_back(CFileReader(buff_prefix + i));
        }
        for(size_t i = 0; i < streams.size(); i++){
            prior_q.add(pair<streams[i].get(), i>);
        }


    }
};
int main()
{
    cout << "Hello world!" << endl;
    return 0;
}