initializing std::string from char* without copy

by

You can’t actually form a std::string without copying the data. A stringstream would probably reuse the memory from pass to pass (though I think the standard is silent on whether it actually has to), but it still wouldn’t avoid the copying.

A common approach to this sort of problem is to write the code which processes the data in step 3 to use a begin/end iterator pair; then it can easily process either a std::string, a vector of chars, a pair of raw pointers, etc. Unlike passing it a container type like std::string, it would no longer know or care how the memory was allocated, since it would still belong to the caller. Carrying this idea to its logical conclusion is boost::range, which adds all the overloaded constructors to still let the caller just pass a string/vector/list/any sort of container with .begin() and .end(), or separate iterators.

Having written your processing code to work on an arbitrary iterator range, you could then even write a custom iterator (not as hard as it sounds, basically just an object with some standard typedefs, and operator ++/*/=/==/!= overloaded to get a forward-only iterator) that takes care of advancing to the next fragment each time it hit the end of the one it’s working on, skipping over whitespace (I assume that’s what you meant by trim). That you never had to assemble the whole string contiguously at all. Whether or not this would be a win depends on how many fragments/how large of fragments you have. This is essentially what the SGI rope mentioned by Martin York is: a string where append forms a linked list of fragments instead of a contiguous buffer, which is thus suitable for much longer values.

UPDATE (since I still see occasional upvotes on this answer):

C++17 introduces another choice: std::string_view, which replaced std::string in many function signatures, is a non-owning reference to a character data. It is implicitly convertible from std::string, but can also be explicitly constructed from contiguous data owned somewhere else, avoiding the unnecessary copying std::string imposes.

More Related Contents:

  1. Parsing a comma-delimited std::string [duplicate]
  2. Remove spaces from std::string in C++
  3. Why should one not derive from c++ std string class?
  4. How to implode a vector of strings into a string (the elegant way)
  5. Case insensitive std::string.find()
  6. Why does C++ allow an integer to be assigned to a string?
  7. Is it reasonable to use std::basic_string as a contiguous buffer when targeting C++03?
  8. Why can’t I write to a string literal while I *can* write to a string object?
  9. std::strings’s capacity(), reserve() & resize() functions
  10. Initial capacity of vector in C++
  11. How to read and write a STL C++ string?
  12. std::string length() and size() member functions
  13. Why doesn’t std::string provide implicit conversion to char*?
  14. Memory allocation and deallocation across dll boundaries
  15. How can I make the map::find operation case insensitive?
  16. “Right” way to deallocate an std::vector object
  17. How to convert a string of hex values to a string?
  18. Memory-efficient C++ strings (interning, ropes, copy-on-write, etc) [closed]
  19. Using getline() in C++
  20. Why is template argument deduction disabled with std::forward?
  21. Is the order of iterating through std::map known (and guaranteed by the standard)?
  22. What is the difference between “new” and “malloc” and “calloc” in C++? [duplicate]
  23. Multidimensional std::array [duplicate]
  24. C++ equivalent of StringBuffer/StringBuilder?
  25. Does std::stack expose iterators?
  26. C++ std::map holding ANY type of value
  27. Do I need to protect read access to an STL container in a multithreading environment?
  28. Why there is no std::copy_if algorithm?
  29. How can I copy one map into another using std::copy?
  30. C++ priority_queue with lambda comparator error

Leave a Comment