std::string vs. char*

Question

does std::string store data differently than a char* on either stack or heap or is it just derived from char* into a class?

Answer 1

char*

• Is the size of one pointer for your CPU architecture.
• May be a value returned from malloc or calloc or new or new[].
  • If so, must be passed to free or delete or delete[] when you're done.
  • If so, the characters are stored on the heap.
• May result from "decomposition" of a char[ N ] (constant N) array or string literal.
  • Generically, no way to tell if a char* argument points to stack, heap, or global space.
• Is not a class type. It participates in expressions but has no member functions.
• Nevertheless implements the RandomAccessIterator interface for use with <algorithm> and such.

std::string

• Is the size of several pointers, often three.
• Constructs itself when created: no need for new or delete.
  • Owns a copy of the string, if the string may be altered.
  • Can copy this string from a char*.
  • By default, internally uses new[] much as you would to obtain a char*.
• Provides for implicit conversion which makes transparent the construction from a char* or literal.
• Is a class type. Defines other operators for expressions such as catenation.
  • Defines c_str() which returns a char* for temporary use.
• Implements std::string::iterator type with begin() and end().
  • string::iterator is flexible: an implementation may make it a range-checked super-safe debugging helper or simply a super-efficient char* at the flip of a switch.

Answer 2

If you mean, does it store contiguously, then the answer is that it's not required but all known (to me, anyway) implementations do so. This is most likely to support the c_str() and data() member requirements, which is to return a contiguous string (null-terminated in the case of c_str())

As far as where the memory is stored, it's usually on the heap. But some implementations employ the "Short String Optimization", whereby short string contents are stored within a small internal buffer. So, in the case that the string object is on the stack, it's possible that the stored contents are also on the stack. But this should make no difference to how you use it, since one the object is destroyed, the memory storing the string data is invalidated in either case.

(btw, here's an article on a similar technique applied generally, which explains the optimization.)

Answer 3

These solve different problems. char* (or char const*) points to a C style string which isn't necessarily owned by the one storing the char* pointer. In C, because of the lack of a string type, necessarily you often use char* as "the string type".

std::string owns the string data it points to. So if you need to store a string somewhere in your class, chances are good you want to use std::string or your librarie's string class instead of char*.

On contiguity of the storage of std::string, other people already answered.