Количество посещений файла

#include "stdafx.h"
#include "ListLib.h"
#include "CheckMask.h"
#include "winsock.h"
#pragma comment(lib,"wsock32.lib")
 
char * integer2ip(unsigned long ip);
int _tmain(int argc, _TCHAR* argv[])
{
    FILE *file;
    char* file_name = "D:\\1\\aaa.nv.com.ua.access";
    char buff[38];     // Массив для ввода символов
 
    int total=0; // количество уникальных посетителей (хостов)
 
    file = fopen(file_name, "r" );
    if (file == 0)
    {
        printf("Такого файла не существует.");
        return(0);
    }
    int i=0;
 
    Node* current;
    Node n0;
    current = n0.makeHead();
 
    while (!feof(file))
    {
        fgets( buff, 38 , file ); 
        // регулярное выражение, выделяем в группу {} ip
        char p[]="{(\\d+.)*\\d+}.*\\d\\d\/\\a+\/\\d+\:\\d+\:\\d+"; 
 
        _bstr_t r;
        
        //Вызов функции, проверяющей строку на наличие в ней ip
        //Результат возвращается в переменную r
        REParseError ResultEx = CheckMaskEx(p,(_bstr_t)buff,&r);
 
        if(ResultEx == REPARSE_ERROR_OK)
        {
            int flag=0;
            // перевод ip к типу unsigned long
            unsigned long ip = inet_addr((char*)r);
            if (current->getIp()==0)
            {
                current = (new Node())->insert(current);
                // создаем первый элемент
                current->setIp(ip);
                current->setCount(1);
            }
            else
            {
                // Обход списка на предмет наличия ip
                current = n0.setCurent();
                for(int i = 0; ; i++ )
                {
                    if (current->getIp()!= ip)
                    {
                        // ip отличный от текущего - идем дальше
                        flag=0;
                        Node* nextNode = current->getNext();
                        if(current->getNext() == 0 ) break;
                        current = nextNode->setCurent();
                    }
                    else
                    {
                        // нашли нужный ip - увеличиваем счетчик
                        flag=1;
                        current->setCount(current->getCount()+1);
                        break;
                    }
                }
                // так ничего и не нашли - создаем новый элемент
                if (flag == 0)
                {
                    current = (new Node())->insert(current);
                    current->setIp(ip);
                    current->setCount(1);
                }
            }
        }
    }
    fclose(file);
 
    current = n0.setCurent();
    current = current->getNext(); // установили указатель списка на первый элемент
 
    // вывод всех хостов
    for(int i = 0; ; i++ )
    {
        printf ("%s\n",integer2ip(current->getIp()));
        total+=1;
        Node* nextNode = current->getNext();
        if(current->getNext() == 0 ) break;
        current = nextNode->setCurent(); 
    }
    printf("Total unique visitors: %d\n",total);
 
    return 0;
}
 
// Функция преобразования ip из числа в строку
char *integer2ip(unsigned long ip)
{
    char s1[20],s2[20],s3[20],s4[20];
    char *s = new char[20];
    strcpy(s,"");
    itoa(ip >> 24,s1,10);
    itoa(ip << 8 >> 24,s2,10);
    itoa(ip << 16 >> 24,s3,10);
    itoa(ip << 24 >> 24,s4,10);
    strcat(s,s4);
    strcat(s,".");
    strcat(s,s3);
    strcat(s,".");
    strcat(s,s2);
    strcat(s,".");
    strcat(s,s1);
    return s;
}

#include <atlrx.h>
#include <comdef.h>
 
/*enum REParseError {
    REPARSE_ERROR_OK = 0,               // No error occurred
    REPARSE_ERROR_OUTOFMEMORY,          // Out of memory
    REPARSE_ERROR_BRACE_EXPECTED,       // A closing brace was expected
    REPARSE_ERROR_PAREN_EXPECTED,       // A closing parenthesis was expected
    REPARSE_ERROR_BRACKET_EXPECTED,     // A closing bracket was expected
    REPARSE_ERROR_UNEXPECTED,           // An unspecified fatal error occurred
    REPARSE_ERROR_EMPTY_RANGE,          // A range expression was empty
    REPARSE_ERROR_INVALID_GROUP,        // A backreference was made to a group
                                        // that did not exist
    REPARSE_ERROR_INVALID_RANGE,        // An invalid range was specified
    REPARSE_ERROR_EMPTY_REPEATOP,       // A possibly empty * or + was detected
    REPARSE_ERROR_INVALID_INPUT,        // The input string was invalid
};*/
REParseError CheckMaskEx(_bstr_t bstrTemplate, _bstr_t bstrText,_bstr_t* bstrResult )
{
    int   j=0;
    CAtlRegExp<> reUrl;
    REParseError status = reUrl.Parse(bstrTemplate);
 
    if (REPARSE_ERROR_OK != status)
    {
        return status;
    }
 
    CAtlREMatchContext<> mcUrl;
    if (!reUrl.Match(bstrText, &mcUrl))
    {
        return REPARSE_ERROR_INVALID_INPUT;
    }
 
    for (UINT nGroupIndex = 0; nGroupIndex < mcUrl.m_uNumGroups;
            ++nGroupIndex)
    {
        const CAtlREMatchContext<>::RECHAR* szStart = 0;
        const CAtlREMatchContext<>::RECHAR* szEnd = 0;
        mcUrl.GetMatch(nGroupIndex, &szStart, &szEnd);
 
        ptrdiff_t nLength = szEnd - szStart;
 
        #ifndef _UNICODE
            char buffer[200];
            j += sprintf(buffer, "%.*s", nLength, szStart);
        #else   // _UNICODE
            WCHAR buffer[200];
            j += swprintf(buffer, L"%.*s", nLength, szStart);
 
        #endif // !_UNICODE
 
        _bstr_t cur(buffer);
        * bstrResult += cur;
        //bstrResult[nGroupIndex] = cur;
            
    }
    
    return REPARSE_ERROR_OK;
}
 
Файл ListLib.h – работа со списком
class Node
{
    unsigned long ip;
    int count;
    Node *next;
public:
    Node()
    {
        ip=0;
        count=0;
        next=0;
    }
    Node* makeHead()
    {
        setIp(0);
        setCount(0);
        next = this;
        return this;
    }
    /*  Вставляет узел после текущего узла*/  
    Node* insert(Node* curent){
        curent->next = this;
        curent = this;
        return curent;
    }
    /*  Устанавливает поле данных узла*/
    void setIp(unsigned long newip){
        ip = newip;
    }
    void setCount(int newcount){
        count = newcount;
    }
    /*  Возвращает указатель на следующий узел*/
    Node* getNext(){
        return next;
    }
    /*  Возвращает поле данных узла */
    int getCount(){
        return count;
    }
    unsigned long getIp(){
        return ip;
    }
 
    /*Устанавливает текущий узел и возвращает указатель на него*/
    Node* setCurent(){
        return this;
    }
};