Jak mogę iterować po ciągu w 128-bitowych porcjach?

Question

Mam funkcję, która działa na 128-bitowych blokach danych z ciągu dowolnej długości. Jeśli łańcuch nie jest równomiernie podzielony na kawałki 128-bitowe, zostanie odpowiednio dopełniony.

Celem jest przekształcenie danych w łańcuchu, który jest wprowadzany do funkcji.

I początkowo myślał o zapętlenie przez String takiego:

//This might have stupid errors. Hopefully it stillg gets the point across. 
for (int i = 0; i < strn.size(); i += 16) 
{ 
    string block = strn.substr(i, i + 15); 
    strn.replace(i, i + 15, block); 
} 

Myślę, że to będzie działać, ale myślę, że musi być bardziej elegancki sposób to zrobić. Jedną z pomysłów, które przychodziły mi do głowy, było zamknięcie klasy strn i implementacja własnego iteratora, który może odczytać jego zawartość w 128-bitowych porcjach. Jest to atrakcyjne, ponieważ konstruktor może obsłużyć dopełnienie, a niektóre funkcje, z których obecnie korzystam, mogą stać się prywatne, co pozwoli uniknąć potencjalnych nadużyć. Czy wydaje się to owocnym podejściem? Jeśli tak, to w jaki sposób można wdrożyć własny iterator? Szczegółowe wyjaśnienia są mile widziane, ponieważ jestem bardzo niedoświadczony w C++.

Czy istnieją inne, być może lepsze, podejścia?

Dzięki!

Answer 1

Istnieje wiele podejść. Jednym z prostszych i prostszych będzie: możesz stworzyć swój własny typ, dokładnie o długości 128 bitów; prosty struct wykona zadanie.

typedef struct 
{ 
    char buf[16]; 
} _128bit; 

I użyć go do powtórzenia ciągu znaków. Rzuć początek łańcucha na ten typ struktury: _128bit* start = (_128bit*)buffer; i rozpocznij iterowanie za pomocą zintegrowanej arytmetyki wskaźnika. Wszystkie operacje na start będą działać pod względem wielkości. Na przykład. , start++ przesunie 128 bitów do przodu; start-- przeniesie 128 bitów z powrotem. Gdy znajdziesz się w pożądanej pozycji, przekształć ją na pożądany typ i wykonaj manipulacje.

Answer 2

I prawdopodobnie to zrobić z iteratorów zamiast indeksowania, nadal używając własnych pętli for:

const int NUM_BITS_IN_CHUNK = 128; 
const int CHUNK_SIZE = NUM_BITS_IN_CHUNK/CHAR_BIT; 

for(std::string::const_iterator iter = str.begin(); iter < str.end(); iter += CHUNK_SIZE) 
{ 
    your_func(iter, iter + CHUNK_SIZE); 
} 

Kod boost :: iterator_adaptor będzie wyglądać następująco. Zauważ, że otrzymuję tylko cztery bajty na porcję zamiast 16 dla uproszczenia w przykładzie:

#include <iostream> 
#include <string> 

#include <boost/iterator_adaptors.hpp> 

struct string_chunk_iterator : public boost::iterator_adaptor<string_chunk_iterator, std::string::const_iterator> 
{ 
    string_chunk_iterator(const std::string::const_iterator& base) : iterator_adaptor(base) { } 

private: 
    friend class boost::iterator_core_access; 
    void increment() { this->base_reference() = this->base() + 4; } 
    void advance(typename iterator_adaptor::difference_type n) 
    { 
     this->base_reference() = this->base() + (4 * n); 
    } 
}; 

int main() 
{ 
    const std::string tester(20, 'A'); 

    string_chunk_iterator iter(tester.begin()); 
    string_chunk_iterator str_end(tester.end()); 

    for(; iter != str_end; ++iter) 
    { 
     std::string chunk(&*iter, &*(iter + 1)); 

     std::cout << chunk << std::endl; 
    } 

    return 0; 
}