Full code

#ifndef _code_h_
#define _code_h_

#include <iostream>
#include <string>
#include <thread>
#include <Windows.h>
#include <stdio.h>
#include <vector>
#include <stdlib.h>
#include <fstream>
#include <array>
#include <iomanip>
#include "lib/aes.h"
#include "lib/modes.h"
#include "lib/filters.h"

using namespace std;
using namespace CryptoPP;
//Read’s data
void readAllDataFromFile(string theFileName,string &outdata)
{
    ifstream fileIn;
    fileIn.open(theFileName, ios::in | ios::binary);
    string *theOutData = new string((istreambuf_iterator<char>(fileIn)), istreambuf_iterator<char>());
    outdata = *theOutData;
    delete(theOutData);
    fileIn.close();
}

// Writes data
void writeDataToFile(string theFileName,string theData)
{
    ofstream fileOut;
    fileOut.open(theFileName, ios::out | ios::binary);
    {
        string out;
        out = theData;
        fileOut.write(out.c_str(), out.size());
        fileOut.close();
        out.resize(10);
        out.shrink_to_fit();
    }
}

void debugNote(string note,int value)
{
    bool debugMode = false;
    if(debugMode)
    {
        cout << note << " " << value << endl;
    }
}
// This class is for AES
class stringAesCypher
{
public:
    void encode (string data,string Skey,string &out)
    {
        byte key[16];
        byte iv[16];
        string bin;
        string theKey(Skey);
        int i(0);
        theKey.append("t;rke;tlrke65409654ytr");

        while(i != 16)
        {
            key[i] = theKey[i];
            iv[i] = theKey[i];
            i++;
        }
        // Encryptor
        CryptoPP::ECB_Mode< CryptoPP::AES >::Encryption
        //Encryptor( key, sizeof(key), iv );
        Encryptor( key, sizeof(key));

      // Encryption
      CryptoPP::StringSource( data, true,
        new CryptoPP::StreamTransformationFilter( Encryptor,
          new CryptoPP::StringSink( out )
        ) // StreamTransformationFilter
      ); // StringSource
    }

    void decode (string CT,string Skey,string &out)
    {
        byte key[16];
        byte iv[16];
        string bin;
        string theKey(Skey);

        int i(0);
        theKey.append("t;rke;tlrke65409654ytr");
        while(i != 16)
        {
            key[i] = theKey[i];
            iv[i] = theKey[i];
            i++;
        }
        // Decryptor
        CryptoPP::ECB_Mode< CryptoPP::AES >::Decryption
        // Decryptor( key, sizeof(key), iv );
        Decryptor( key, sizeof(key) );

      // Decryption
      CryptoPP::StringSource( CT, true,
        new CryptoPP::StreamTransformationFilter( Decryptor,
          new CryptoPP::StringSink( out )
        ) // StreamTransformationFilter
      ); // StringSource
    }
};
// This class is for Tea the cypher that does not need to be linked
class stringTeaCypher
{
    private:
    void decodeXtea(unsigned int* v, unsigned int* w, unsigned int* k) {
        register unsigned int v0=v[0], v1=v[1], i, sum=0xC6EF3720;
        register unsigned int delta=0x9E3779B9;
        for(i=0; i<32; i++) {
            v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
            sum -= delta;
            v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);
        }
        w[0]=v0; w[1]=v1;
    }
    void encodeXtea(unsigned int* v, unsigned int* w, unsigned int* k) {
        register unsigned int v0=v[0], v1=v[1], i, sum=0;
        register unsigned int delta=0x9E3779B9;
        for(i=0; i<32; i++) {
           v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + k[sum & 3]);
            sum += delta;
            v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + k[(sum>>11) & 3]);
        }
        w[0]=v0; w[1]=v1;
    }
    void TeaDecode ( const std::string& str, const std::string& key, std::string* out )
    {
        unsigned int v[2];
        unsigned int w[2];
        unsigned int k[4];
        unsigned int keybuffer [ 4 ];

        // Clear buffers
        memset ( v, 0, sizeof(v) );
        memset ( w, 0, sizeof(w) );
        memset ( k, 0, sizeof(k) );
        memset ( keybuffer, 0, sizeof(keybuffer) );
        out->clear ();

        // Count the number of passes that we need
        int numBlocks = str.length() / 4;
        int numPasses = numBlocks - 1;

        if ( numPasses <= 0 )
            return;

        // Process the key
        int len = key.length ();
        if ( len > 16 )
            len = 16;
        memcpy ( keybuffer, key.c_str(), len );
        for ( int i = 0; i < 4; ++i )
            k[i] = keybuffer[i];

        // Create a temporary buffer to store the result
        unsigned char* buffer = new unsigned char [ numPasses * 4 + 4 ];
        memset ( buffer, 0, numPasses * 4 + 4 );

        // Decode it!
        const char* p = str.c_str();
        v[1] = *(unsigned int*)&p[numPasses * 4];
        for ( int i = 0; i < numPasses; ++i )
        {
            v[0] = *(unsigned int*)&p[(numPasses-i-1)*4];
            decodeXtea ( &v[0], &w[0], &k[0] );
            *(unsigned int*)&buffer[(numPasses-i-1)*4] = w[0];
            v[1] = w[1];
        }

        out->assign ( (char *)buffer, numPasses*4 );
        delete [] buffer;
    }
    void TeaEncode ( const std::string& str, const std::string& key, std::string* out )
    {
        unsigned int v[2];
        unsigned int w[2];
        unsigned int k[4];
        unsigned int keybuffer [ 4 ];

        // Clear buffers
        memset ( v, 0, sizeof(v) );
        memset ( w, 0, sizeof(w) );
        memset ( k, 0, sizeof(k) );
        memset ( keybuffer, 0, sizeof(keybuffer) );
        out->clear ();

        // Process the key
        int len = key.length ();
        if ( len > 16 )
            len = 16;
        memcpy ( keybuffer, key.c_str(), len );
        for ( int i = 0; i < 4; ++i )
            k[i] = keybuffer[i];

        // Copy the input string to a buffer of size multiple of 4
        int strbuflen = str.length ();
        if ( strbuflen == 0 )
            return;
        if ( (strbuflen % 4) > 0 )
            strbuflen += 4 - (strbuflen % 4);
        unsigned char* strbuf = new unsigned char [ strbuflen ];
        memset ( strbuf, 0, strbuflen );
        memcpy ( strbuf, str.c_str(), str.length() );

        // Encode it!
        v[1] = 0;
        for ( int i = 0; i < strbuflen; i += 4 )
        {
            v[0] = *(unsigned int*)&strbuf[i];

            encodeXtea ( &v[0], &w[0], &k[0] );
            out->append ( (char*)&w[0], 4 );

            v[1] = w[1];
        }
        out->append ( (char*)&v[1], 4 );

        delete [] strbuf;
    }
    public:
    void encode(string inString,string key,string &out)
    {
        TeaEncode(inString,key,&out);
    }
    void decode(string inString,string key,string &out)
    {
        TeaDecode(inString,key,&out);
    }
};
// The other stuff put into a class
class Core
{
    private:
    string theMainBuffer;
    vector <string> ram;
    long int encodeSize,decodeSize,bufferSize;
    string mode;
    string key;
    size_t count;
        int getSizeOfString(string theString)
        {
            return theString.length();
        }
        void cores(int rRam)
        {
            string ramTemp("");
            //stringAesCypher Code;
            stringTeaCypher Code;

            if(mode == "E")
            {
                Code.encode(ram[rRam],key,ramTemp);
            }
            if(mode == "D")
            {
                Code.decode(ram[rRam],key,ramTemp);
            }
            ram[rRam] = ramTemp;
        }
        void startCores()
        {
            thread t1(&Core::cores,this,0);
            thread t2(&Core::cores,this,1);
            thread t3(&Core::cores,this,2);
            thread t4(&Core::cores,this,3);
            thread t5(&Core::cores,this,4);
            thread t6(&Core::cores,this,5);
            thread t7(&Core::cores,this,6);
            thread t8(&Core::cores,this,7);
            t1.join();
            t2.join();
            t3.join();
            t4.join();
            t5.join();
            t6.join();
            t7.join();
            t8.join();
        }
        void splitData ()
        {
            int theShift(theMainBuffer.length()/8);
            cout << theShift << "the divide " << theMainBuffer.length() << endl;
            int place(0);
            for(int i = 0; i != 8; i++)
            {
                if(place == theMainBuffer.length())
                {
                    cout << "break" << endl;
                }
                else
                {
                    ram[i] = theMainBuffer.substr(place,theShift);
                    cout << place << endl;
                    place = place + theShift;
                }
            }

            theMainBuffer = "";
        }
        void unsplitData()
        {
            theMainBuffer = "";
            for(int i = 0; i != 8; i++)
            {
                theMainBuffer.append(ram[i]);
                ram[i] = "";
            }
        }
    public:
    Core();
        void setMode(string theMode)
        {
            mode = theMode;
        }
        void setKey(string theKey)
        {
            key = theKey;
        }
        void readFile(string inputFileName,string outputFileName)
        {
            int theSize(0);
            if(mode == "E"){theSize = encodeSize;}
            if(mode == "D"){theSize = decodeSize;}
            // Size and file streams
            ifstream fileStreamIn(inputFileName,ios::binary);
            ofstream fileStreamOut(outputFileName,ios::binary);
                // The main loop
                while(fileStreamIn)
                {
                    fileStreamIn.read(&theMainBuffer.front(),theSize);// Reads
                    count = fileStreamIn.gcount();// Read ammount
                    theMainBuffer.resize(count);
                    splitData();
                    startCores();
                    unsplitData();

                    fileStreamOut.write(theMainBuffer.c_str(),theMainBuffer.length()); // write
                    cout << "Data in flow " << count << " Data encoder outflow " << theMainBuffer.length() << endl;
                }
            fileStreamIn.close();
            fileStreamOut.close();
        }

};

Core::Core()
{
    encodeSize = 256;
    decodeSize = 288;
    /*
    Tea Large
    encodeSize = 100000000;
    decodeSize = 100000032;
    */
    /*
    AES
    encodeSize = 100000000;
    decodeSize = 100000128;
    */
    //bufferSize = 100000138;
    bufferSize = 360;
    ram.resize(8);
    theMainBuffer.resize(bufferSize);
}

#endif