Загрузка процессора при поиске по регулярному выражению

//#include "Header.h"
#include "curl.h"
#include "dirent.h"
#pragma comment(lib,"curllib.lib")
#include <iostream>
#include <map>
#include <string>
#include <time.h>
#include <regex>
using namespace std;
 
 
class Array{
public:
 
    Array();
    ~Array();
 
    wstring & operator [] (const wstring&);
    wstring & operator [] (const int&);
    void unset(const wstring&);  // удалить
    int length(void);        // вернуть длину массива
    void unique(void);       // уникализировать массив
    bool in_array(const wstring&); // поиск значения в массиве
    void push(const wstring&,const wstring&); //взтавить ключ+значение (функция только для вставки, работает в 2 раза быстее чем [])
    void push(const int&,const wstring&); //взтавить ключ+значение (функция только для вставки, работает в 2 раза быстее чем [])
    void clear();
    void print(void){
        for( map < wstring, wstring, less<wstring> >::iterator i = my_map.begin( ); i !=my_map.end( ); ++i )
            wcout << ( *i ).first << ":" << ( *i ).second << endl;
    }
 
 
private:
 
    map < wstring, wstring, less<wstring> > my_map;
 
 
 
 
};
 
Array::Array(){
 
}
 
Array::~Array(){
    my_map.clear();
}
 
 
void Array::clear(){
    my_map.clear();
}
void Array::push(const wstring& _key,const wstring& _value){
    my_map.insert( map < wstring, wstring, less<wstring>>::value_type( _key, _value ) );
}
 
void Array::push(const int& _key,const wstring& _value){
    my_map.insert( map < wstring, wstring, less<wstring>>::value_type( to_wstring(_key), _value ) );
}
 
wstring & Array::operator [] (const wstring &_key){
 
    if(my_map.find( _key )!= my_map.end( )) {
        return my_map[_key];
    }else{
        my_map.insert( map < wstring, wstring, less<wstring>>::value_type( _key, L"" ) );
        return my_map[_key];
    }
 
}
wstring & Array::operator [] (const int &_key){
 
    if(my_map.find( to_wstring(_key) )!= my_map.end( )) {
        return my_map[to_wstring(_key)];
    }else{
        my_map.insert( map < wstring, wstring, less<wstring>>::value_type( to_wstring(_key), L"" ) );
        return my_map[to_wstring(_key)];
    }
 
}
 
void Array::unset(const wstring& _key){
    my_map.erase(_key);
}
 
int Array::length(){
    return my_map.size();
}
 
void Array::unique(){
 
    map <wstring, wstring, less<wstring> > time_map;
    for( map < wstring, wstring, less<wstring> >::iterator i = my_map.begin( ); i !=my_map.end( ); ++i )
    {
        time_map.insert( map <wstring, wstring, less<wstring>>::value_type( ( *i ).second, ( *i ).first ) );
    }
    my_map.clear();
    for( map < wstring, wstring, less<wstring> >::iterator i = time_map.begin( ); i !=time_map.end( ); ++i )
    {
        my_map.insert( map < wstring, wstring, less<wstring>>::value_type( ( *i ).first, ( *i ).second ) );
    }
    time_map.clear();
}
 
bool Array::in_array(const wstring& _value){
    bool result = false;
    for( map < wstring, wstring, less<wstring> >::iterator i = my_map.begin( ); i !=my_map.end( ); ++i )
    {
        if(( *i ).second == _value){
            result = true;
        }
    }
    return result;
}
 
void preg_match_all(char *_regular,const string &_text,Array &_result){
 
    smatch base_result;
    ssub_match base_sub_match;
    string result;
    wstring utf_str;
 
    char * temp;
    wchar_t * wtemp;
 
    string::const_iterator ib = _text.begin(), ie = _text.end();
 
    for(int i = 0; regex_search(ib, ie,base_result, regex(_regular,regex_constants::icase)); ib = base_result[0].second, i++)
    {
 
        for (size_t i2 = 0; i2 < base_result.size(); i2++) {
            result = base_result[i2];
            temp = (char*)result.c_str();
            wtemp = new wchar_t[result.length()+1];
            mbstowcs(wtemp,temp,result.length()+1);
            utf_str = wtemp;
            utf_str[result.length()]= '\0';
            delete[]wtemp;
            _result.push(i+i2,utf_str);
 
        }
        i+=base_result.size()-1;
    }
}
static int writer(char *data, size_t size, size_t nmemb, string *buffer)
{
    //переменная - результат, по умолчанию нулевая
    int result = 0;
    //проверяем буфер
    if (buffer != NULL)
    {
        //добавляем к буферу строки из data, в количестве nmemb
        buffer->append(data, size * nmemb);
        //вычисляем объем принятых данных
        result = size * nmemb;
    }
    //вовзращаем результат
    return result;
}
void main()  {
    map < wstring, int, less<wstring> > map_url;
    string result;
    while(true){
        Array result_url;
        setlocale(LC_ALL,".886");
        CURL *curl;
        CURLcode res;
 
 
        curl = curl_easy_init();
        if(curl) {
            curl_easy_setopt(curl, CURLOPT_URL, "https://www.cyberforum.ru");
            curl_easy_setopt(curl, CURLOPT_HEADER, 1);
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
 
            //указываем функцию обратного вызова для записи получаемых данных
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
            //указываем куда записывать принимаемые данные
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &result);
            res = curl_easy_perform(curl);
            curl_easy_cleanup(curl);
        }
 
 
 
 
        preg_match_all("<a(.*?)href(.*?)\"(.*?)\"(.*?)>",result,result_url);
 
        for (int i = 0,i2=0; i < result_url.length(); i++,i2++)
        {
            if(i2 == 3){
 
 
                map_url.insert( map < wstring, int,less<wstring>>::value_type( result_url[i] ,0) );
                i2 = -2;
            }
        }
        result_url.clear();
 
 
    }
 
}