Dfyjkt

if i declare a variable of type std::string but do not initialize it, how much memory is allocated? I know that if I initialize it to "hello" for example, there will be a byte reserved for each character plus one for the null character, 6 total. Is there a default length defined somewhere in the string class?
(I've tried looking for the actually definition in the string header file but don't know where to find it)

It's unspecified. Different implementations may allocate different amounts of memory upon default-construction, and an implementation is not required to tell you how much memory that is. However, I believe that right now it's most common for std::string to employ a short string optimization, under which a default-constructed std::string need not allocate any memory at all besides the size of the std::string class itself. See Meaning of acronym SSO in the context of std::string for details. Note that sizeof(std::string) is also unspecified.

While that is unspecified, there is something worth mentioning: In practice, implementations avoid allocating memory for uninitialized strings.

I have performed a few tests for usual sizeof(std::string) using Compiler Explorer (link to the test). Here are the results, though you can of course experiment with more:

• gcc / Linux / x86-64 / libstdc++ : 32 bytes
  


• gcc / Linux / x86 / libstdc++ : 24 bytes
  


• clang / Linux / x86-64 / libc++ (NB: not libstdc++!) : 24 bytes
  


• clang / Linux / x86 / libc++ : 12 bytes
  


• msvc / Windows / x86-64 / VC runtime : 32 bytes
  


• msvc / Windows / x86 / VC runtime : 24 bytes
  


• gcc / Linux / ARM64 / libstdc++ : 32 bytes
  


• gcc / Linux / ARM (32-bit) / libstdc++ : 24 bytes


• msvc / Windows / ARM64 / VC runtime : 32 bytes (NB: output is in hex on CE)

Roughly speaking, in practice, a std::string object is going to be 12 to 32 bytes big, excluding the dynamically allocated memory.

These results are depending mostly on the standard library implementation and CPU architecture (because of whatever standard library feels like doing).

Note that these sizes do include SSO, which @Brian discussed in his answer. I believe this is the motive for libstdc++ and MS' implementation to use 32 bytes rather than 24 (since I suspect that there are usually 3 pointers involved: data begin, data end and capacity end), though I don't know the specifics.

You can always check youself. It depends on the computer you are at, to check datatype sizes you can always use size:of.

In your case it would look like this

#include <iostream>
#include <string>

int main() 
 std::string a = "";

 std::cout << sizeof(a) << 'n';

 system("PAUSE");
 return 0;

I get 28 bytes.