Join (concatenate) vector of strings to char buffer with zero byte as delimiter/terminator

Question

Is there any better way to convert vector of string to the vector of chars with zero terminator between strings.

So if I have a vector with the following strings "test","my","string", then I want to receive one vector of chars: "test\0my\0string\0".

At this moment this code works fine, but is there any better (more beautiful) solution?

std::vector<std::string> string_array = {"test", "my", "string"};
std::vector<char> buffer_temp;
for (auto &str : string_array)
{
    for (auto &chr : str)
    {
        buffer_temp.push_back(chr);
    }
    buffer_temp.push_back('\0');
}

Possible duplicate of [How to implode a vector of strings into a string (the elegant way)](https://stackoverflow.com/questions/5689003/how-to-implode-a-vector-of-strings-into-a-string-the-elegant-way) — moooeeeep, Jun 29 '17 at 06:46
@Lundin get your facts straight, `std::string` is not null-terminated. — n. m. could be an AI, Jun 29 '17 at 06:48
@n.m. When you push back the string into the char array, a null terminator gets appended. Simply print the raw data of the char vector and see for yourself. I guess this sequence on my screen is just me smoking C++1x weed, right? `116 101 115 116 0 109 121 0 115 116 114 105 110 103 0 0` — Lundin, Jun 29 '17 at 06:49
@Lundin Pushing raw data is not the same as iterating the string. Run the damn code and see what it does. — n. m. could be an AI, Jun 29 '17 at 06:51
@n.m. Which I did before posting the comment. Why don't you run it yourself. — Lundin, Jun 29 '17 at 06:51
@Lundin when you iterate a `std::string`, you won't observe a null terminator. — moooeeeep, Jun 29 '17 at 06:51
@Lundin: Don't be sarky. There are a number of Windows API calls where this is *exactly* the memory layout that is required. — Martin Bonner supports Monica, Jun 29 '17 at 06:55
@moooeeeep And? What has iterating a std::string got to do with anything? I'm talking about the code in the question. — Lundin, Jun 29 '17 at 06:56
In addition, the standard does not require that the std::string contains a null terminator (it can be appended by .c_str()). The fact that all existing implementations do append one is neither here nor there. — Martin Bonner supports Monica, Jun 29 '17 at 06:56
Yes. That's how the code knows it has got to the end of the series of strings. — Martin Bonner supports Monica, Jun 29 '17 at 06:57
@MartinBonner More commonly they would use a NULL pointer as sentinel. But if you say so. — Lundin, Jun 29 '17 at 06:58
@Lundin I'm not sure what exactly you ran but [here goes](http://ideone.com/UC6Zjo) — n. m. could be an AI, Jun 29 '17 at 06:59
@Lundin: How do you store a NULL pointer in a char buffer? The code to iterate over the sequence of strings is `for (; *p; p += strlen(p)+1) {...}` — Martin Bonner supports Monica, Jun 29 '17 at 07:23

Loamsiada · Answer 1 · 2017-06-29T06:49:24.327

1

Directly copying the string data might be faster for long strings.

 std::vector<std::string> string_array = {"test", "my", "string"};
 int size = 0;
 for (auto &str : string_array)
 {
     size += str.size()+1;
 }

 char * buffer = new char[size];
 int cursor = 0;
 for (auto &str : string_array)
 {
     memcpy(&buffer[cursor], str.data(), str.size());
     cursor += str.size()+1;
     buffer[cursor-1] = '\0';
 }

edited Jun 29 '17 at 06:49

answered Jun 29 '17 at 06:43

Loamsiada

444
3
11

I would write `std::vector buffer(size);` and `size_t cursor;`. You can also write `memcpy(&buffer[cursor], str.c_str(), str.size()+1);` to copy the zero terminator as well. (In *theory*, `.c_str()` can allocate a new buffer, but no actual implementation does this.) – Martin Bonner supports Monica Jun 29 '17 at 06:49
1

You should not copy into the raw char data of a string object (there is a reason why it is const char*), this is why I prefer a char array. – Loamsiada Jun 29 '17 at 06:58

Akira · Accepted Answer · 2017-06-29T10:00:02.593

1

Never forget the std::vector::insert method with which your example can be simplified as follows:

std::vector<std::string> string_array = { "test", "my", "string" };
std::vector<char> buffer_temp;

for(auto& s : string_array)
    buffer_temp.insert(buffer_temp.end(), s.c_str(), s.c_str() + s.size() + 1);

The std::string::c_str returns a pointer to a null-terminated character array, so you don't have to append an extra '\0' to the end of each element coming from your string_array.

Responding to comments below, you can use std::string iterators as well, and because the std::string has random-access iterator you can do the following:

for(auto& s : string_array)
    buffer_temp.insert(buffer_temp.end(), s.begin(), s.end() + 1);

edited Jun 29 '17 at 10:00

answered Jun 29 '17 at 07:25

Akira

4,385
3
24
46

1

If you use stringstream, you can access the char array directly via ss.str().data(). There is no need to copy it to buffer_temp. – Loamsiada Jun 29 '17 at 07:33
I've removed the `std::stringstream` example since there is no need to it if the desired delimiter is `'\0'`. – Akira Jun 29 '17 at 08:33
2

You should change that to `{ buffer_temp.insert(buffer_temp.end(), s.begin(), s.end()); buffer_temp.push_back('\0'); }` - just because it looks more innocent. – moooeeeep Jun 29 '17 at 09:27

Join (concatenate) vector of strings to char buffer with zero byte as delimiter/terminator

2 Answers2