Создайте абстрактный базовый класс при этом все алгоритмы реализуются в своих наследниках и у всех одинаковый интерфейс

#include <string>
#include <map>
#include <vector>
#include <bitset>
#include <iostream>
#include <fstream>
#include <sstream>
#include <thread>
using namespace std;
 
 
 
class RLE
{
 
public: 
    
    void RLE_coding()
    {
 
        char sym; //символ, который мы будем считывать
        int kol = 1;// количество повторяющихся символов
 
 
       ifstream RLE_input("INPUT_TEXT.txt");
        ofstream RLE_compr("RLE_COMPRESSED_TEXT.txt");
        while (RLE_input.good())
        {
            RLE_input.get(sym);//считываем символ
            if (sym != RLE_input.peek()) // если символ не совпадает со следующим символом в файле
            {
                RLE_compr << kol << sym; // записываем результаты в выходной файл
                kol = 0;
            }
            kol++;
        }
 
        RLE_input.close();
        RLE_compr.close();
    }
 
    void RLE_decoding()
    {
 
        ifstream RLE_input("RLE_COMPRESSED_TEXT.txt");
        ofstream RLE_decompr("RLE_DECOMPRESSED_TEXT.txt");
 
        char sym1, sym2; // предыдущий и последующий символы
        const char zero = '0';
        while (RLE_input.peek() != EOF)
        {
            RLE_input.get(sym1);
            RLE_input.get(sym2);
            for (int i = 0; i < sym1 - zero; i++)
                RLE_decompr << sym2;
        }
 
        RLE_input.close();
        RLE_decompr.close();
 
    }
};
 
class ARF
{
public:
    string poem;
    long double ver;                    // вероятности символов
    char symbol;                  // наименование символа
    long double low;                    // Нижняя граница
    long double high;                  // Верхняя граница
 
 
 
    friend string operator>>(ifstream& ustream, ARF& entry)
    {
        if (typeid(ustream) == typeid(ifstream))
            ustream >> entry.poem;
        return entry.poem;
    }
 
    void ARFalg() {
        int size = 0;
        double maxCompression = 0;
        string poem;
        ifstream ARF_input("INPUT_TEXT.txt");
        getline(ARF_input, poem);
        ARF ARF1;
        ARF ARF2;
        ARF ARF3;
        ARF ARF4;
        ARF ARF5;
 
        size = ARF1.uniqueSymbol(poem);
        // cout << size << endl;
        ARF* mas = new ARF[size];
        ARF2.FullMas(mas, poem);
        ARF3.defineBoundaries(mas, size);
        long double result = ARF4.ARF_coding(poem, mas, size);
        //cout << result << endl;
        ofstream ARF_compr("ARF_COMPRESSED_TEXT.txt");
 
        ARF_compr << "Таблица кода: " << endl;
 
        for (int i = 0; i < size; i++)
        {
            ARF_compr << mas[i].symbol << ": [" << mas[i].low << " : " << mas[i].high << ")" << endl;
            maxCompression += mas[i].ver * log2(1 / mas[i].ver);
        }
        ARF_compr << "Итоговый результат: " << endl << result << endl;
 
        string decode = ARF5.ARF_decoding(result, mas, size, poem.length());
        //cout << decode << endl;
        ofstream ARF_decompr("ARF_DECOMPRESSED_TEXT.txt");
        ARF_decompr << decode;
 
        ARF_input.close();
        ARF_compr.close();
        ARF_decompr.close();
    }
 
    double ARF_coding(string entered, ARF mas[], int size)
    {
        long double low = 0.0;
        long double high = 1.0;
        for (int i = 0; i < entered.length(); i++)
        {
            int tmp = 0;
            for (int j = 0; j < size; j++)
            {
                if (mas[j].symbol == entered[i])
                {
                    tmp = j;
                    break;
                }
            }
            long double CodeRange = high - low;
            high = low + CodeRange * mas[tmp].high;
            low = low + CodeRange * mas[tmp].low;
 
        }
        return (low + high) / 2;
 
    }
    string ARF_decoding(long double code, ARF mas[], int size, int length)
    {
        string result;
        long double encode = code;
        int iter = 0;
        int presence = 0;
        for (int i = 0; i < length; i++)
        {
            for (iter = 0; iter < size; iter++)
            {
                if (encode >= mas[iter].low && encode < mas[iter].high)
                {
                    result.push_back(mas[iter].symbol);
                    break;
                }
            }
            long double range = mas[iter].high - mas[iter].low;
            encode -= mas[iter].low;
            encode /= range;
        }
        return result;
    }
 
    void FullMas(ARF mas[], string entered)
    {
        int iter = 0;
 
        for (int i = 0; i < entered.length(); i++)
        {
            bool presence = false;
            for (int j = iter; j >= 0; j--)
            {
                if (entered[i] == mas[j].symbol)
                {
                    presence = true;
                    mas[j].ver++;
                    break;
                }
            }
            if (presence == false)
            {
                mas[iter].symbol = entered[i];
                mas[iter].ver = 1;
                iter++;
            }
        }
        for (int i = 0; i <= iter; i++)
        {
            mas[i].ver /= entered.length();
        }
    }
    void defineBoundaries(ARF mas[], int size)
    {
        long double low = 0.0;
        for (int i = 0; i < size; i++)
        {
            mas[i].low = low;
            mas[i].high = low + mas[i].ver;
            low += mas[i].ver;
        }
    }
    int uniqueSymbol(string entered)
    {
        int size = 0;
        for (int i = 0; i < entered.length(); i++)                // Подсчет уникальных символов
        {
            bool presence = false;
            for (int j = i - 1; j >= 0; j--)
            {
                if (entered[i] == entered[j])
                {
                    presence = true;
                    break;
                }
            }
            if (presence == false)
            {
                size++;
            }
        }
        return size;
    }
};
 
class LZ78
{
public:
    int index;
    string data;
    LZ78* next;
 
    void LZalg() {
        string input;
        ifstream aza("INPUT_TEXT.txt");
        getline(aza, input);
        LZ78 C;
        string result = C.LZ_coding(input);
        ofstream rez("LZ_COMPRESSED_TEXT.txt");
        rez << result;
        rez.close();
        aza.close();
 
        ifstream aza_dec("LZ_COMPRESSED_TEXT.txt");
        getline(aza_dec, input);
        LZ78 B;
        string result2 = B.LZ_decoding(input);
        ofstream rez_dec("LZ_DECOMPRESSED_TEXT.txt");
        rez_dec << result2;
        rez_dec.close();
        aza_dec.close();
    }
 
    void st_Node(LZ78* head, int index, string data) {
        head->index = index;
        head->data = data;
        head->next = NULL;
    }
 
    void insert_Node(LZ78* head, int index, string data) {
        LZ78* new_Node = new LZ78;
        new_Node->index = index;
        new_Node->data = data;
        new_Node->next = NULL;
 
        LZ78* curr = head;
        while (curr != NULL)
        {
            if (curr->next == NULL)
            {
                curr->next = new_Node;
                return;
            }
            curr = curr->next;
        }
    }
 
    LZ78* search_Node(LZ78* head, string data)
    {
        LZ78* curr = head;
        while (curr != NULL)
        {
            if (data.compare(curr->data) == 0)
                return curr;
            else
                curr = curr->next;
        }
        return NULL;
    }
 
    LZ78* search_Node(LZ78* head, int index)
    {
        LZ78* curr = head;
        while (curr != NULL)
        {
            if (index == curr->index)
                return curr;
            else
                curr = curr->next;
        }
        return NULL;
    }
 
    vector <string> split(string str, char delimiter) {
        vector<string> internal;
        stringstream ss(str);
        string tok;
 
        while (getline(ss, tok, delimiter)) {
            internal.push_back(tok);
        }
 
        return internal;
    }
 
    string LZ_coding(string input)
    {
 
        LZ78* dictionary = new LZ78;
        string word, result;
        int length, last_seen, index = 1;
 
        length = (int)input.length();
        word = input[0];
        st_Node(dictionary, 1, word);
        result += "0," + word;
 
        for (int i = 1; i < length; i++)
        {
            string data;
            data = input[i];
 
        re_check:
            LZ78* search = search_Node(dictionary, data);
 
            if (search)
            {
                i++;
                data += input[i];
                last_seen = search->index;
                goto re_check;
            }
            else
            {
                char zero;
                if (input[i] == ' ')
                    zero = '0';
                else
                    zero = input[i];
 
                if ((int)data.length() < 2)
                    result += " " + to_string(0) + "," + zero;
                else
                    result += " " + to_string(last_seen) + "," + zero;
 
                index++;
                if (i != length)
                    insert_Node(dictionary, index, data);
            }
        }
 
        return result;
    }
 
    string LZ_decoding(string input)
    {
 
        LZ78* dictionary = new LZ78;
        string result2;
 
        vector <string> s_input = split(input, ' ');
        int zz = 2;
        for (int i = 0; i < s_input.size(); i++)
        {
            vector <string> ss_input = split(s_input[i], ',');
 
            if (i == 0)
            {
                st_Node(dictionary, 1, ss_input[1]);
                result2 += ss_input[1];
            }
            else
            {
                LZ78* serched;
                string get_search = ss_input[1];
                serched = search_Node(dictionary, stoi(ss_input[0]));
                if (serched)
                {
                    result2 += serched->data + get_search;
                    get_search = serched->data + split(s_input[i], ',')[1];
                    insert_Node(dictionary, zz, get_search);
                }
                else
                {
                    if (stoi(ss_input[0]) == 0)
                        insert_Node(dictionary, zz, get_search);
                    else
                        insert_Node(dictionary, zz, get_search);
 
                    result2 += get_search;
                }
                zz++;
            }
        }
 
        if (result2[(int)result2.length() - 1] == '0')
            result2 = result2.substr(0, result2.size() - 1);
 
        return result2;
    }
 
};
 
 
int main()
{
        //�'ыбор ----
    setlocale(LC_ALL, "Russian");
    int choice = 0;
    cout << "Введите 1 для алгоритма RLE;" << endl << "Введите 2 для алгоритма ARF;" << endl << "Введите 3 для алгоритма LZ78;" << endl;
    cin >> choice;
        auto start = chrono::high_resolution_clock::now();
    if (choice == 1)
    {
        
    RLE RLE1;
    RLE RLE2;
        RLE1.RLE_coding();// вызов функции кодирования алгоритм RLE
        RLE2.RLE_decoding();// вызов функции декодирования алгоритм RLE
        auto stop = chrono::high_resolution_clock::now();
        chrono::duration<float> duration = stop - start;
        system("cls");
        cout << "Время выполнение алгоритма RLE: " << duration.count() << endl;
    }
    else if (choice == 2)
    {
        ARF ARFS;
        ARFS.ARFalg();//вызов функции кодирования/деодирования ARF
        auto stop = chrono::high_resolution_clock::now();
        chrono::duration<float> duration = stop - start;
        system("cls");
        cout << "Время выполнение алгоритма ARF: " << duration.count() << endl;
    }
    else if (choice == 3)
    {
        LZ78 LZ78start;
        LZ78start.LZalg();//вызов функции кодирования/деодирования LZ78
        auto stop = chrono::high_resolution_clock::now();
        chrono::duration<float> duration = stop - start;
        system("cls");
        cout << "Время выполнение алгоритма LZ78: " << duration.count() << endl;
    }
    cout << "Алгоритм выполнен, результат в корневой папке" << endl;
    return 0;
    system("PAUSE");
}