утечка памяти

void main()
{
    std::string alph = "!#qwertyabce1234";
    for (int length = 4; length < 8; length++)
    {
        std::string alphtmp = alph;
        std::string randompass;
        std::random_shuffle(alphtmp.begin(), alphtmp.end());
        for (auto it = alphtmp.begin(); it < alphtmp.begin() + length; ++it)
        {
            randompass += *it;
        }
        std::cout << "pass length: " << length << std::endl;
 
 
        float fTimeStart1 = clock() / (float)1000;// старт замера времени
        for (const auto &password : all_words(alph, length))//////////////////////////вызов функции
        {
            if (password == randompass) 
            { 
                std::cout << "found" << std::endl;
                break;
            }
            
        }
        float fTimeStop1 = clock() / (float)1000;// окончание замера времени с точностью до 0.00001 сек
 
        std::cout << "time: " << fTimeStop1 - fTimeStart1 << std::endl;
        std::cout << "___________________________________ " << std::endl;
    }
    
}

std::vector<std::string> all_words(const std::string &alphabet, int max_length) {
    // Return all possible different words that can be created with symbols from the alphabet.
    // Alphabet - string of symbols, symbols are repeated.
    // Words length - from 1 up to max length included, i.e. in [1, max_length].
    // Order of words in the result isn't important.
    // Return empty array if there are no symbols in the alphabet or if max length is less then 1.
    
    int length;
    std::string word;
    std::string tmpword;
    std::vector<std::string> result;
    int index;
 
    if ((max_length != 0)&&(alphabet.size() != 0))
    {
        for (auto el : alphabet)
        {
            word = el;
            result.emplace_back(word);
            index = result.size() - 1;
            length = result[index].size();
            while (length < max_length )
            {
                word = result[index];
                for (auto nextel : alphabet)
                {
 
                    tmpword = word;
                    tmpword += nextel;
                    result.push_back(tmpword);
                }
                index++;
                length = result[index].size();
            }
 
        }
    }
    return result;
}

///----------------------------------------------------------------------------|
/// Эмулятор взломщика сейфа.
///----------------------------------------------------------------------------|
/// У нас есть:
///     1. Сейф.
///     2. Сейф заперт и к нему нужен ключ.
///     3. Авантюрист, который будет подбирать к нему ключ.
///     4. Авантюрист знает алфавит из которого состои ключ.
///     5. Но не знает длину ключа, но догадывается в каком она диапазоне.
///
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <Windows.h>
 
///----------------------------------------------------------------------------|
/// Конфигурация.
///----------------------------------------------------------------------------:
struct sConfigure
{   const char* alphabet;   // Алфавит.
    int         lenght;     // Длина пароля на сейфе.
    int         lenght_max; // Диапазон длины подбора пароля
    int         lenght_min;
    bool        is_visual;  // Визуализация паролей на переборе. 
};
const  sConfigure CONFIG = {
    "!#qwertyabce1234",
    4,   // lenght
    7,   // lenght_max
    3,   // lenght_min
    true // is_visual -> визуализация ВКЛЮЧЕНА!!! ВНИМАНИЕ: УВЕЛИЧИВАЕТ ВРЕМЯ!
};
 
#define DEBUGLOG(v)   std::cout << #v << " = " << v << "\n"
#define BANNER(a,b,c) std::cout <<"\n"<< a <<"\n"<< b <<"\n"<< c <<"\n";
#define MESSAG(a,b)   std::cout << a << ": " << b << "\n"
#define COLOR(N,C)    ""; mySetColor(C);std::cout<<N;mySetColor();std::cout
 
void mySetColor(UINT text = 7, UINT background = 0) // #include <Windows.h>
{   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                        (WORD)((background << 4) | text));
}
 
struct smystart
{   smystart()
    {   setlocale(0, "");
        system("mode 50,50");
        srand(time(NULL));
    }
}sys;
int rrand(int range_min, int range_max)
{   return rand() % (range_max - range_min + 1) + range_min;
}
///----------------------------------------------------------------------------|
/// Сейф который нужно взломать.
///----------------------------------------------------------------------------:
class cSafe
{
public:
    cSafe(const std::string& alphabet, size_t length) : 
        is_open(false),
        money  (1000000)
    {                                         BANNER(
        "///--------------------------------------|",
        "/// Был создан SAFE.                     |",
        "///--------------------------------------:")
        password = generator(alphabet, length);
        std:: cout << "Password: " << COLOR(password, 10) << "\n\n";
    }
    
    ///-----------------------------------|
    /// Место куда вставлять ключ.        |
    ///-----------------------------------:
    bool open_safe(const std::string& pass)
    {   if(pass == password)
        {   is_open = true;
            return true;
        }
        return false;
    }
    
    void close()
    {   is_open = false;
        std::cout << "Ключ скрипнул...\n\n";
    }
    
    ///-----------------------------------|
    /// Доступ к мани, если сейф открыт.  |
    ///-----------------------------------:
    unsigned int get_money(unsigned int _money)
    {   if(is_open)
        {   std::cout << "Cейф открыт... ";
            if(money < _money)
            {   std::cout << "Тут нет столько!\n\n";
                return 0;
            }
            std::cout << "Вы взяли money!\n\n";
            money -= _money;
            return _money;
        }
        std::cout << "SAFE заперт!\n\n";
        return 0;
    }
    
    void test()
    {   std::cout << "SAFE тест...\n\n";
    }
    
private:
    bool is_open;
    unsigned int money;
    std::string password;
    ///------------------------------------------------------------------------|
    /// Данный генератор будет создаваь пароли из заданного алфавита alphabet
    /// с рандомной длиной из диапазона значений: (length-1, length+1)
    ///------------------------------------------------------------------------:
    std::string generator(const std::string& alphabet, size_t length)
    {   
        //length = rrand(length-1, length+1);
    
        char* buf = new char[length+1]; buf[length] = 0;
        for(int i = 0; i < length; i++)
        {   buf[i] = alphabet[rrand(0, alphabet.size()-1)];
        }
        std::string pass(buf);
        delete[] buf;
        
        return pass;
    }
};
 
///----------------------------------------------------------------------------|
/// Авантюрист.
///----------------------------------------------------------------------------:
class cAdventurer
{   std::string& alphabet;
    cSafe*       safe;
public:
    cAdventurer(std::string& _alphabet) :   alphabet(_alphabet),
                                            safe    (NULL   ),
                                            temp    ("****"), 
                                           _test    (false),
                                            good    (false)
    {}
    
    std::string hack( cSafe* _safe,  int length)//-------------------------hack:
    {   if ((length == 0)||(alphabet.size() == 0)) return "";
        safe = _safe;
                                              BANNER(
        "///--------------------------------------|",
        "/// Авантюрист приступил к подбору ключа.|",
        "///--------------------------------------:")
        MESSAG("Длина ключа: ", length);
        _test = CONFIG.is_visual;
        
        for(temp = ""; temp.size() != length; temp += '*');
    
        good = false;
        std::string result;
        std::cout << "Идёт подбор пароля ... ";
        foo();
        //DEBUGLOG(temp);
        if(good) return temp;
        return result = "", result;
    }
    
private:
    ///-----------------------------------|
    /// Брутфорсер.                       |
    ///-----------------------------------:
    std::string temp;
    int k;
    int foo(int k = 0)//----------------------------------------------------foo:
    {   if(k == temp.size()){   return 0;}
        
        for(int i = 0; i < alphabet.size(); i++)
        {   temp[k] = alphabet[i];
            if(_test) std::cout << "\r"
                                << temp << "                                  ";
            
            if(safe->open_safe(temp))
            {   std::cout << "\n... что-то внутри ... приятно скрипуло ...\n";
                good = true;
                return -1;
            }
            if(foo(k+1) == -1) return -1;
        }
    }
    
public:
    bool _test;
    test(cSafe* _safe)
    {   safe = _safe;
        safe->test();
        std::string s = alphabet;
        alphabet = "a2345";
        _test    = true;
         foo();
        _test    = false;
        alphabet = s;
        safe     = NULL;
    }
    bool good;
};
 
#define PERFOMANCE_START {float fTimeStart1 = clock() / (float)1000;
#define PERFOMANCE_END   float fTimeStop1 = clock() / (float)1000;\
            std::cout << "\ntime: " << fTimeStop1 - fTimeStart1 << std::endl;\
            std::cout << "___________________________________ " << std::endl;}
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{   std::string alphabet = CONFIG.alphabet;
    
    ///-------------------------------------|
    /// SAFE.                               |
    ///-------------------------------------:
    cSafe safe (alphabet, CONFIG.lenght);
          safe.get_money(100000);
    
    ///-------------------------------------|
    /// Авантюрист.                         |
    ///-------------------------------------:
    cAdventurer adventurer(alphabet);
              //adventurer.test(&safe);
      
    ///-------------------------------------|
    /// Авантюрист в деле.                  |
    /// Авантюрист знает алфавит, но        |
    /// не знает длину ключа, но            |
    /// догадывается в каком она диапазоне. |
    ///-------------------------------------:
    std::string find;
    for (int length = CONFIG.lenght_min; length <= CONFIG.lenght_max; length++)
    {
PERFOMANCE_START;
        find = adventurer.hack(&safe, length);
PERFOMANCE_END;
            
        if( find.size() != 0)
        {   mySetColor(2);
            std::cout << "    Пароль найден!\n    пароль: " 
                      << COLOR(find, 10) << "\n";
            break;
        }
             
        else std::cout << "Провал!!! Ты лузер!\n";
    }
 
    MESSAG("\nАвантюрист хочет взять: ", 10000000);
    if (safe.get_money(10000000) == 0);
    {   MESSAG("... тогда пробует взять: ", 1000000);
        safe.get_money(1000000);
    }
    
    safe.close();
    safe.get_money(0);
    
                            BANNER(
    "///------------------------|",
    "/// Программа ЗАВЕРШЕНА... |",
    "///------------------------:")
    std::cin.get();
    return 0;
}