how to copy std::vector<const char*> into void*? - c++

Question

I have a std::vector<const char*> v vector fully initiated with strings. How do I copy it into an initialized void*?
int main() {
std::vector<const char*> v;
v.push_back("abc");
v.push_back("def");
void* b = malloc(6);
// how to copy v in to b?
}
Thank you

Answer 1

You can use the range based for statement. For example
void *p = b;
for ( const char *s : v )
{
size_t n = std::strlen( s );
std::memcpy( p, s, n );
p = ( char * )p + n;
}
The same can be done with standard algorithm std::accumulate declared in header <numeric>
For example
#include <iostream>
#include <vector>
#include <numeric>
#include <cstring>
int main()
{
std::vector<const char*> v;
v.push_back( "abc" );
v.push_back( "def" );
void *b = new char[6];
auto p = std::accumulate( v.begin(), v.end(), b,
[]( void *acc, const char *s ) -> void *
{
size_t n = std::strlen( s );
return ( ( char * )std::memcpy( acc, s, n ) + n );
} );
std::cout.write( (const char * )b , ( const char * )p - ( const char * )b );
std::cout << std::endl;
return 0;
}
The output is
abcdef
Take into account that it would be better to write
void* b = new char[6];

Answer 2

Iterate through the vector moving your pointer along by the string length each time.

Answer 3

int currentIndex = 0;
for(int i = 0; i < v.length(); i++) {
memcpy(b + currentIndex, v[i], strlen(v[i]));
currentIndex += strlen(v[i]);
}
Something like that, may not work I didn't test it.
And if you want to use b as a string, you need to put a 0 on the end.

Answer 4

try this :
std::vector<const char*> v;
v.push_back("abc");
v.push_back("def");
void* b = malloc(6);
int l = strlen(v[0]);
memcpy(b, v[0], l);
l = strlen(v[1]);
memcpy(b+l, v[1], l);

Answer 5

This is the most C++-like way I can think of. It doesn't use any C-style string manipulation or memory management functions and it is as safe as can be. Downside is that a temporary buffer is allocated and released without actual need.
The following headers are used in this example.
#include <cstddef>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
Now, the first version (which I prefer) allocates a buffer of the correct size and returns it wrapped in a std::unique_ptr<char[]> from which the caller can then extract the buffer and implicitly cast it to void * if needed.
std::unique_ptr<char[]>
concatenate(const std::vector<const char *>& words)
{
std::string buffer {};
std::unique_ptr<char[]> dup_uptr {};
for (const auto word : words)
buffer += word;
dup_uptr.reset(new char[buffer.size() + 1]);
buffer.copy(dup_uptr.get(), buffer.size());
dup_uptr.get()[buffer.size()] = '\0';
return dup_uptr;
}
The second version takes the destination buffer and its size as parameters and copies the concatenated string there. This can obviously fail if the buffer happens to be too small and it is also less safe since we might make a mistake and pass the wrong buffer size. For convenience, it returns a char * pointer to the string or a nullptr if the buffer was too small.
char *
concatenate(const std::vector<const char *>& words,
void *const dest,
const std::size_t size)
{
char * dest_chars = static_cast<char *>(dest);
std::string buffer {};
for (const auto word : words)
buffer += word;
// If we cannot copy the whole thing, copy nothing at all.
if (buffer.size() >= size)
return nullptr;
buffer.copy(dest_chars, buffer.size());
dest_chars[buffer.size()] = '\0';
return dest_chars;
}
The two functions can be used like this:
int
main()
{
const std::vector<const char*> vec {"abc", "def"};
// first version
{
auto concat = concatenate(vec);
std::cout << concat.get() << std::endl;
}
// second version
{
auto tempbuff = std::get_temporary_buffer<void>(100);
if (auto concat = concatenate(vec, tempbuff.first, tempbuff.second))
std::cout << concat << std::endl;
std::return_temporary_buffer(tempbuff.first);
}
return 0;
}