How do I cast `std::string` to `std::vector` without making a copy?

Question

There is a library function I want to call whose signature is:

bool WriteBinary(const std::vector<uint8_t> & DataToWrite);

I have an std::string variable, I want to send it this function as argument.

void WriteString(const std::string & TextData)
{
    // ...
    WriteBinary(TextData);  // <-- How to make this line work?
    // ...
}

Is there a way I can directly send the std::string variable without making a copy of it?

I found a lot of questions about reverse conversion, but couldn't find anything exactly about casting from string to vector. If this happened to be a duplicate I apologize in advance. — hkBattousai, May 16 '13 at 19:21
This is why the standard library always uses a pair of iterators to specify a sequence, so you don't run into this problem. — Mark Ransom, May 16 '13 at 19:26
If it did exist, it would almost certainly have to be `std::swap(TextData, myVector)`, but as the answers say, it does not exist. — Ben Jackson, May 16 '13 at 19:38
If all sequential data types in STL would have been implementing, say, an abstract `sequence<>` class, you could have done it by wrapping your strings in a `string_based_sequence<>` class. However, that's not the case. And STL is supposed to be object-oriented... — Eser Aygün, May 16 '13 at 19:50
Uh, C++ is a bit broken in this regard :) Reminds me of [my case with two strings but a different allocators](http://stackoverflow.com/questions/16321531/reference-stdbasic-string-specialization-of-string-with-custom-allocator-as-a). I did what I wanted, but there is no safe way, especially in your case. You will have to take risks :) — , May 16 '13 at 20:01
@EserAygün: [No, the STL was not supposed to be Object-Oriented.](http://www.stlport.org/resources/StepanovUSA.html). BTW, the overhead of virtual access would have killed `std::vector`, and we'd still be using `T[]`. — MSalters, May 16 '13 at 21:54

score 11 · Answer 1 · answered May 16 '13 at 19:28

There's no way to do this, because the layouts of the two types are not guaranteed to be similar in any way.

The best approach is to fix WriteBinary to use "iterators" instead:

bool WriteBinary(const unsigned char* first, const unsigned char* last);

Or template it:

template <typename Iter>
bool WriteBinary(Iter first, Iter last);

And then you can use it for strings, vectors, or any other container you like!

Otherwise you can use the iterator constructor to do the copy as efficiently as possible:

WriteBinary(std::vector<uint8_t>(TextData.begin(), TextData.end()));

score 5 · Answer 2 · answered May 16 '13 at 19:23

5

I am afraid that is not possible. Neither string nor vector has a constructor which would allow it to "adopt" a pre-existing buffer. And it's very likely the memory layout of a string and a vector differ, so there is no casting possible.

answered May 16 '13 at 19:23

Angew is no longer proud of SO

167,307
17
350
455

score 2 · Answer 3 · answered May 16 '13 at 19:43

Is there a way I can directly send the std::string variable without making a copy of it?

No, certainly not safely.

If you have control over the library, I'd suggest a slight refactor.

Either add:

template<typename CharT>
void WriteBinary(CharT const* buffer, size_t count);

Or:

template<typename FwdIter>
void WriteBinary(FwdIter begin, FwdIter end);

And then make your existing WriteBinary and WriteString call it:

void WriteBinary(std::vector<uint8_t> const& vec)
{ WriteBinary(&*vec.begin(), vec.size()); }

void WriteString(std::string const& s)
{ WriteBinary(&*s.begin(), s.size()); }

Or:

void WriteBinary(std::vector<uint8_t> const& vec)
{ WriteBinary(vec.begin(), vec.end()); }

void WriteString(std::string const& s)
{ WriteBinary(s.begin(), s.end()); }

Personally, I'd prefer the iterator based approach. It feels "cleaner".

(Note: for the pointer/size approach, you'd probably want to check for empty. Some implementations may assert if you deference the result of begin() on an empty vector/string.)

Pixelchemist · Accepted Answer · 2013-05-17T09:21:24.430

You are of course free to hack yourself through to obtain the desired result. But you should prepare for a summary execution by co-workers or people wanting to use/maintain/modify or port your code...

... don't do it!...

int main (void)
{
  std::string teststring("HERE IS A TEST");
  char * p = (char*)malloc(3*sizeof(char*) + sizeof(std::allocator<char>));
  std::allocator< std::allocator<char> > alloc_alloc;
  char * pa = p + 3*sizeof(char*);
  alloc_alloc.construct((std::allocator<char>*)pa);

  char const * cp = teststring.data();
  char const * * vec_it = (char const**)p;

  vec_it[0] = cp;
  vec_it[1] = cp + teststring.length();
  vec_it[2] = vec_it[1];

  std::vector<char> &a_vector = *((std::vector<char, std::allocator<char>>*)p);

  cout << a_vector.size() << " elements in vector!" << endl;

  for (std::vector<char>::iterator i=a_vector.begin(); i!=a_vector.end(); ++i) 
  {
    cout << *i;
  }
  cout << endl;
  // set char 8 to 66 = B
  a_vector[8] = 66;

  cout << teststring << endl;

}

Prints

14 elements in vector!
HERE IS A TEST
HERE IS B TEST

Note:

As correctly mentioned in the comments, this solution relys on the vector to have the following data layout and requires the string to store it's data contiguously (dunno whether this is predetermined by the standard).

template <typename T>
class vector
{
  T* _first, _last, _end;
  std::allocator<T> _alloc;
};

This is the true answer to my question. Thank you. However, I will comply with your recommendation and won't use it. I will pass iterators for this purpose in the way the other answers have suggested. — hkBattousai, May 17 '13 at 02:47
You should at least mention that this answer is **extremely** dependent on the internal implementation of `std::vector` and `std::string` in the particular standard library used. — Angew is no longer proud of SO, May 17 '13 at 08:43

How do I cast `std::string` to `std::vector` without making a copy?

4 Answers4

... don't do it!...

Note: