Sizeof and Containers

Yes, you can use sizeof with std::string or std::vector, but the result might not be what you expect.

When you use sizeof with a class type like std::string or std::vector, it returns the size of the object itself, not the size of the data it might be managing internally.

sizeof with Dynamically Allocated Data

std::string and std::vector are designed to handle dynamically allocated data. This means they typically store a pointer to the actual data (the characters of the string or the elements of the vector), which is stored elsewhere in memory (usually on the heap).

The size of this dynamically allocated data can change at runtime as you add or remove elements. However, the std::string or std::vector object itself has a fixed size, which includes things like:

• A pointer to the dynamically allocated data
• The current size of the data (how many elements are stored)
• The capacity (how much memory has been allocated)

What sizeof Returns

When you call sizeof on a std::string or std::vector, you're getting the size of this fixed-size object, not the size of the dynamically allocated data.

Here's an example to illustrate this:

1#include <iostream>
2#include <string>
3#include <vector>
4
5int main() {
6  std::string MyString{"Hello"};
7  std::vector<int> MyVector{1, 2, 3, 4, 5};
8
9  std::cout << "sizeof(std::string): "
10    << sizeof(std::string) << " bytes\n";
11  std::cout << "sizeof(MyString): "
12    << sizeof(MyString) << " bytes\n";
13  std::cout << "sizeof(std::vector<int>): "
14    << sizeof(std::vector<int>) << " bytes\n";
15  std::cout << "sizeof(MyVector): "
16    << sizeof(MyVector) << " bytes\n";
17}

1sizeof(std::string): 40 bytes
2sizeof(MyString): 40 bytes
3sizeof(std::vector<int>): 32 bytes
4sizeof(MyVector): 32 bytes

Example Explanation

On many 64-bit systems, you might see that sizeof(std::string) is 32 bytes and sizeof(std::vector<int>) is 24 bytes. These sizes will be the same regardless of the contents of the string or vector.

The actual string data ("Hello") and the vector data (1, 2, 3, 4, 5) are stored elsewhere in memory, and their sizes don't affect the result of sizeof applied to the std::string or std::vector object itself.

Getting the Size of Dynamically Allocated Data

If you want to know the number of elements in a std::vector, you should use the size() method. For std::string, you can also use size() or length(). These methods return the number of elements (or characters), which is different from the result of sizeof.

1#include <iostream>
2#include <string>
3#include <vector>
4
5int main() {
6  std::string MyString{"Hello"};
7  std::vector<int> MyVector{1, 2, 3, 4, 5};
8
9  std::cout << "MyString.size(): "
10    << MyString.size() << "\n";
11  std::cout << "MyVector.size(): "
12    << MyVector.size() << "\n";
13}

1MyString.size(): 5
2MyVector.size(): 5

It's important to understand this distinction when working with dynamically sized containers. sizeof gives you the size of the container object itself, while size() or length() gives you the number of elements it's currently holding.