всем добрый.
ниже приведу реализацию, которая написана на чистом Си.
Буду вам очень благодарен если поможите использование массивов но на STL.
главные учавствующие эл-ты — pIp_packet[], ppIp_packet[][], parr_sequence_number[]
смысл действий заключается в след.:
1) читается бинарный файл
2) содержимое бинарного файла складируем в pIp_packet, для этого используем вспомогат. эл-т pIp_packet_tmp.
3) дальше из pIp_packet_tmp распихиваю в массив ppIp_packet, каждый эл-т является Ip пакет.
4) в каждом Ip пакете есть дополнит. поле, назовем X1, так вот эл-т этого поля будем еще складировать в парал-ный массив parr_sequence_number.

Задача:
Хотелось бы реализовать на STL сортировку эл-тов ppIp_packet (т.е. Ip пакетов) используя сортировку parr_sequence_number, который однозначно связаны.

На С все прекрасно работат, сортировку сделал ч\з указатели.

// создаю массив ppIp_packet[] - складируются Ip пакеты 
Fun1() 
{
    bool X2 = false;
    
     fl_in.Open(s_dest_file, CFile::modeRead | CFile::typeBinary,  &e);
     ULONGLONG i_filesize = fl_in.GetLength();
     
    // выделяю память под чтение файла
        if( i_filesize > 1024*1024*200)
        {
            /*ULONGLONG*/ read_block1024_1024_200 = 1024*1024*200;
            
            read_block_200Mb = new u_char [int(read_block1024_1024_200)];
            pIp_packet    = (u_char*) new u_char[int(read_block1024_1024_200)];
            

            X2 = true;
        }
        else
        {
            read_block_200Mb = new u_char [int(i_filesize)];
            pIp_packet    = (u_char*) new u_char[int(i_filesize)];
            
            X2 = false;

        }
        
        // создаю временную перемен. для использов. pIp_packet
        u_char *pIp_packet_tmp = pIp_packet; // !!!


    do // читаю файл по большим кускам в переменную и так до конца !
    {

        if(X2)
        {
            read_block1024_1024_200 = fl_in.Read(read_block_200Mb, 1024*1024*200) ;
        }
        else
        {
            read_block1024_1024_200 = fl_in.Read(read_block_200Mb, int(i_filesize)) ;
        }
        ULONGLONG inc_read_block_200Mb = 0;
        if(!read_block1024_1024_200)
        {
            //MessageBox("Файл не прочитался при  %d -ом чтении !", inc_read);
            delete [] pIp_body_buff;
            delete [] pIp_h_buff;
            break;
        }

        do // читаю файл по пакетно и так до конца !
        {
            --inc_read_block_200Mb;
            memcpy(pIp_h_buff,&read_block_200Mb[inc_read_block_200Mb], 20);

            ip_h_ver = (int)getBits(pIp_h_buff,0,0, 4);
            s_ip_ver.Format("%d", ip_h_ver);

            ip_h_len = (int)getBits(pIp_h_buff,0,4, 4);
            s_ip_h_len.Format("%d", ip_h_len);

            ip_full_length = (int)getBits(pIp_h_buff,0,16, 16);
            s_ip_len.Format("%d", ip_full_length);

            ip_h_protocol = (int)getBits(pIp_h_buff,0,72, 8);
            s_protocol.Format("%d", ip_h_protocol);

            pIp_body_buff = (u_char*) new u_char[ip_full_length-ip_h_len*4];
            inc_read_block_200Mb += ip_h_len*4;
            memcpy(pIp_body_buff,&read_block_200Mb[inc_read_block_200Mb], ip_full_length-ip_h_len*4);
            inc_read_block_200Mb += ip_full_length-ip_h_len*4;
            ip_body = ip_full_length-ip_h_len*4;


            // заполняю pIp_packet_tmp[] 
            memcpy(pIp_packet_tmp, pIp_h_buff, ip_h_len*4);
            pIp_packet_tmp+=ip_h_len*4;        
            memcpy(pIp_packet_tmp, pIp_body_buff, ip_body);
            pIp_packet_tmp+=ip_body;


            delete [] pIp_body_buff;
            pIp_body_buff = NULL;

            inc_pack++;

        }while(inc_read_block_200Mb < read_block1024_1024_200);

    }while(read_block1024_1024_200>1);
    
    ...
    ppIp_packet = new u_char* [inc_pack];

    // содержимое pIp_packet_tmp[] теперь распихиваю по пакетно в каждый ppIp_packet[i]
    for(int i=0; i<inc_pack; i++)
    {
        ppIp_packet[i] = new u_char [(int)getBits(pIp_packet_tmp,0,16, 16)];
        memcpy(ppIp_packet[i], pIp_packet_tmp, (int)getBits(pIp_packet_tmp,0,16, 16));
        pIp_packet_tmp+=getBits(pIp_packet_tmp,0,16, 16);
    }
        FullArrSequenceNumber();
}

// Из каждого ppIp_packet[i] извлекаю значения поля и записываю в parr_sequence_number[i]
int FullArrSequenceNumber()
{
    int ip_h_len, ip_len, ip_body; 

    parr_sequence_number = new int [inc_pack];
    u_char *p_tmp;
    int old_sequence_number = 0;

    if(ppIp_packet != NULL)
    {
        for(int i=0; i < inc_pack; i++)
        {
            ip_h_len = (int)getBits(ppIp_packet[i],0, 4, 4);
            ip_h_len *=4;
            ip_len = (int)getBits(ppIp_packet[i],0,16, 16);
            ip_body = ip_len - ip_h_len;
            p_tmp = new u_char [ip_body];

            memcpy(p_tmp, &ppIp_packet[i][ip_h_len], ip_body);
            //GRE_analyse(p_tmp);

            if((int)getBits(p_tmp,0, 3, 1) == 0x1)
            {
                parr_sequence_number[i] = (int)getBits(p_tmp,0, 64, 32);
                old_sequence_number        = parr_sequence_number[i];
            }
            else
            {
                parr_sequence_number[i] = old_sequence_number;
            }
        }
        return true;
    
    }
    
    return false;
}