Как скопировать часть массива WCHAR в массив BYTE?

byte bDataBlocks[crypto.block_size] = {0};      // Буффер
WCHAR * wTextIn = new WCHAR[eLen[0]];           // Массив под текст(ввод)
WCHAR * wTextOut = new WCHAR[eLen[0] + 16];     // Массив под текст(вывод)

unsigned chunk = 0; // Счётчик. + 16 - для записи потому, что записан 1й блок
 
while(chunk < eLen[0]) // Цикл по строке
{
    std::copy(wTextIn + chunk, wTextIn + chunk + 16, reinterpret_cast<WCHAR *>(bDataBlocks));   // Копировать текст по 16 байт в буффер
    (crypto.*whats_to_do)(bDataBlocks, bDataBlocks);                // Шифровать блок
    memcpy(wTextOut[chunk + 16], bDataBlocks, 16 * sizeof(BYTE));   // Записать 1й блок
    chunk += 16; // Прибавлять по 16
}

wTextOut[chunk + 16]

WCHAR * wTextIn = new WCHAR[eLen[0]];           // Массив под текст(ввод)
GetWindowTextW(hEdit[1], wTextIn, eLen[0] + 1); // Считать текст из поля

BYTE * bData = new BYTE[eLen[0] * 2];           // Массив под данные(ввод)
std::copy(wTextIn, wTextIn + eLen[0], reinterpret_cast<WCHAR *>(bData));    // Копировать двух байтовую строку в массив байт

BYTE bDataBlocks[16] = {0};     // Буффер

BYTE bDataBlocks[crypto.block_size] = {0};      // Буффер для шифрования, 16 ячеек
 
WCHAR * wTextIn = new WCHAR[eLen[0]];           // Массив под текст(ввод)
GetWindowTextW(hEdit[1], wTextIn, eLen[0] + 1); // Получить текст из поля(без нуль терминатора)
 
BYTE * bDataIn = new BYTE[eLen[0] * 2];                                     // Массив под данные(ввод), в него копируется весь текст
std::copy(wTextIn, wTextIn + eLen[0], reinterpret_cast<WCHAR *>(bDataIn));  // Копировать двух байтовую строку в массив байт
 
BYTE * bDataOut = new BYTE[eLen[0] - ((eLen[0] % 16) - 16) * 2 + 16];       // Массив под данные(вывод), в него копируются шифрованные данные
 
unsigned long long llDataLenght = eLen[0];      // Длина всего текста
 
for(int i = 0; i < 8; ++i) bDataBlocks[i] = llDataLenght >> (i * 8); // Записать длину текста в буфер побайтово
 
(crypto.*whats_to_do)(bDataBlocks, bDataBlocks);    // Шифровать 1й блок
 
unsigned chunk = -1;    // Счётчик. потом + 16 - для записи потому, что записан 1й блок
 
while(++chunk < 16) bDataOut[chunk] = bDataBlocks[chunk];   // Копировать 1й блок
//memcpy(wTextOut, bDataBlocks, 16 * sizeof(BYTE)); // Записать 1й блок
 
while(chunk < eLen[0]) // Цикл, пока не кончатся данные
{
    for(int j = 0, i = (chunk - 16); i < chunk; ++i)    // Копировать данные по 16 байт в буффер
    {
        if(i < eLen[0]) // Если данные не кончились
        {
            bDataBlocks[i] = bDataIn[i];    // Копировать данные
            j++;                            // Считать скопированные данные
        }
        else if(j < 15) // Если данные кончились, а буффер заполнен не до конца
        {
            while(j < 16)   // Дополнить буффер до конца
            {
                bDataBlocks[j] = 0; // Записать ноль
                j++;                // Считать скопированные данные
            }
            break;  // Разрушить цикл копирования в буффер
        }
        else break; // Если данные закончились и буффер полностью забит, разрушить цикл копирования в буффер
    }
    (crypto.*whats_to_do)(bDataBlocks, bDataBlocks);    // Шифровать блок
    
    for(int i = chunk; i < (chunk += 16); ++i) bDataOut[chunk] = bDataBlocks[chunk];    // Копировать зашифрованный блок в массив вывода
}

BYTE * bDataIn = new BYTE[eLen[0] * 2];

BYTE bDataBlocks[crypto.block_size] = {0};

Length; // Длина bDataIn 
unsigned NumOfBlocks = Length / 16; // Количество целых блоков
for (unsigned i = 0; i < NumOfBlocks; ++i) {
  memcpy(bDataBlocks, bDataIn + i * 16, sizeof(BYTE) * 16); // Копируем 16 байт i-го блока
  // Шифруем блок
}
 
unsigned LastBytes = Length % 16;
if (LastBytes) { // Если есть неполный блок
  memcpy(bDataBlocks, bDataIn + NumOfBlocks * 16, sizeof(BYTE) * LastBytes); // Копируем остаток
  memset(bDataBlocks + LastBytes, 0, sizeof(BYTE) * (16 - LastBytes)); // Дописываем нули в конец
  NumOfBlocks += 1;
  // Шифруем последний блок
}

memcpy(bDataOut + i + 16 * 16, bDataBlocks, sizeof(BYTE) * 16);

memcpy(pB + i, pA, sizeof(pA[0]) * N);

unsigned eLen[4];
eLen[0] = GetWindowTextLengthW(hEdit[1]); // Текст

unsigned long long llDataLenght = eLen[0];      // Длина всего текста
 
for(int i = 0; i < 8; ++i) bDataBlocks[i] = llDataLenght >> (i * 8); // Записать длину текста в буфер побайтово

BYTE bDataBlocks[crypto.block_size] = {0};      // Буфер для шифрования, 16 ячеек

memcpy(bDataBlocks, eLen[0], sizeof(unsigned));         // Копировать длину данных в буфер
memset(bDataBlocks + sizeof(unsigned), 0, sizeof(BYTE) * (16 - sizeof(unsigned)));      // Добить буфер нулями

memcpy(bDataBlocks, &eLen[0], sizeof(unsigned));