The easiest way to repeat a sequence of bytes into a larger buffer in C ++

Question

Given (in C ++)

char * byte_sequence;
size_t byte_sequence_length;
char * buffer;
size_t N;

Assuming that byte_sequencethey are byte_sequence_lengthinitialized with some arbitrary sequence of byte lengths (and its length), and bufferinitialized to indicate N * byte_sequence_lengthbytes, what would be the easiest way to replicate byte_sequenceat a buffer Ntime? Is there anything in STL / BOOST that is already doing something like this?

For example, if the sequence were "abcd", but Nwas 3, then it bufferwould eventually contain "abcdabcdabcd".

Answer 1

I would probably just go with this:

for (int i=0; i < N; ++i)
    memcpy(buffer + i * byte_sequence_length, byte_sequence, byte_sequence_length);

, , '\0'.

, c-, '\0' a. c- , :

char *RepeatN(char *source, size_t n)
{
    assert(n >= 0 && source != NULL);            
    size_t length = strlen(source) - 1;
    char *buffer = new char[length*n + 1];
    for (int i=0; i < n; ++i)
        memcpy(buffer + i * length, source, length);
    buffer[n * length] = '\0';
}

Answer 2

, :

std::vector <char> std::string, . .

, :

• .
• .

.

//Note this works even for binary data.
void appendSequenceToMyBuffer(std::string &sBuffer
       , const char *byte_sequence
       , int byte_sequence_length
       , int N)
{
  for(int i = 0; i < N; ++i)
      sBuffer.append(byte_sequence, byte_sequence_length);
}

//Note: buffer == sBuffer.c_str()

---

: memcpy:

buffer = new char[byte_sequence_length*N];
for (int i=0; i < N; ++i)
  memcpy(buffer+i*byte_sequence_length, byte_sequence, byte_sequence_length); 
//...
delete[] buffer;

---

: strcpy:

buffer = new char[byte_sequence_length*N+1];
int byte_sequence_length = strlen(byte_sequence);
for (int i=0; i < N; ++i)
  strcpy(buffer+i*byte_sequence_length, byte_sequence, byte_sequence_length); 
//...
delete[] buffer;

---

: :

buffer = new char[N];
memset(buffer, byte_value, N);
//...
delete[] buffer;

Answer 3

STL Generate:

MSDN:

Answer 4

, N 2, , :

assert((N > 0) && ((N & (N-1)) == 0));
memcpy(buffer, byte_sequence, byte_sequence_length);
for (size_t i = 1;  i < N;  i *= 2)
    memcpy(buffer + i * byte_sequence_length, buffer, i * byte_sequence_length);

: , , N 2. , N, while.

if (N > 0)
    memcpy(buffer, byte_sequence, byte_sequence_length);
size_t copied = 1;
while (copied < N)
{
    size_t tocopy = min(copied, N - copied);
    memcpy(buffer + copied * byte_sequence_length, buffer, tocopy * byte_sequence_length);
    copied += tocopy;
}