sizeof() on C++ Standard Library

Question

I got curious and applied sizeof() operator on some C++ standard Library Classes. Here is what I have observed:

int main() 
{
    vector<double> v1;
    set<double> s1;
    map<double,double> m1;

    stack<char> st;
    queue<char> q;

    vector<char>  v2;
    set<char> s2;
    map<char,char> m2;

    cout<<sizeof(v1)<<" "<<sizeof(s1)<<" "<<sizeof(m1)<<endl;
    cout<<sizeof(v2)<<" "<<sizeof(s2)<<" "<<sizeof(m2)<<endl;
    cout<<sizeof(q)<<" "<<sizeof(st)<<endl;
    return 0;
}

The output on my system (64-bit) is:

12 24 24
12 24 24
40 40

I know that std::set uses Red-Black tree for implementation. So a each node of a binary tree has two pointers(8 bytes each) and the value(8 bytes, total 24) seems alright.

std::map(also uses Red-Black trees) has an extra key, but still 24 bytes? Why?
Why std::queue and std::stack take 40 bytes while std::vector takes only 12 bytes?
Why char and double does not affect the size of the class? Is it because of the templates?

`sizeof` is not a function, but an operator and keyword defined in the C++ language. — Basile Starynkevitch, Jul 04 '13 at 14:37
@VaughnCato I was expecting that `sizeof(container)>=sizeof(node)` — banarun, Jul 04 '13 at 14:52
Why would you expect that? The container could be nothing but a wrapper around a pointer to the root node, for example. — Yakk - Adam Nevraumont, Jul 04 '13 at 14:53
@banarun: Why? The nodes are not stored in the container object itself. They are stored dynamically, and referenced in the container object (probably by pointers). — Benjamin Lindley, Jul 04 '13 at 14:53
@Yakk and Benjamin Lindley Thanks. I understood that I was wrong — banarun, Jul 04 '13 at 14:55
You may have a 64-bit system but you are using a 32-bit compiler. — n. m. could be an AI, Jul 04 '13 at 14:56

Some programmer dude · Answer 1 · 2013-07-04T14:41:06.783

6

The implementation of these classes is a black box, there is no way of telling what data or private members they contain. It's totally up to the implementation.

The only way to know what all the bytes in the object instance are, is to read the source code.

edited Jul 04 '13 at 14:41

answered Jul 04 '13 at 14:35

Some programmer dude

400,186
35
402
621

Doesn't sizeof() tell the size of the class irrespective of private or public members? – banarun Jul 04 '13 at 14:44
1

@banarun Yes, `sizeof` returns the size of all members, but you don't know what they are. And just because a class have a size of 24 bytes doesn't mean it has 3 pointer. – Some programmer dude Jul 04 '13 at 14:48

score 5 · Accepted Answer · answered Jul 04 '13 at 14:59

The sizeof operator will give you the size of a type.

Now, if I were to make an very simplified version of the std::vector<T> here (note this doesn't do ANYTHING as much as a REAL implementation does, and it's far too simplified to really work - and I'm skipping over lots of bits that you really need in a real one):

template<typename T>
class vector<T>
{
   public:
      typedef size_t size_type;
   private:
     T* mdata;
     size_type msize;
     size_type mreserved;
   public:
     vector() { mreserved = msize = 0; mdata = 0; }
     vector(size_type sz) { msize = 0; mreserved = sz; mdata = new T[sz](); }
     void push_back(const T& v) 
     { 
        if (msize + 1 > mreserved) grow(mreserved * 2);
        mdata[msize+1] = v;
        msize++;
     }
     size_type size() const { return msize; }
     // bunch of other public functions go here. 
   private:
     void grow(size_type newsize)
     {
        if (newsize < 8) newsize = 8;
        T* newdata = new T[newsize]; 
        for(size_type i = 0; i < msize; i++) newdata[i] = mdata[i];
        swap(mdata, newdata);
        delete [] mdata;
        mreserved = newsize;
     }
  };

As you can see, the size of the actual class is identical (it contains the same size and number of elements) no matter how large the set of data stored is. In other words, the sizeof(vector<int>) is constant. The size of the data stored behind mdata is of course changing, but sizeof doesn't know (can't know) that.

Armen Tsirunyan · Answer 3 · 2013-07-04T14:49:35.677

This sample source code will give you the idea:

struct A
{
    int* p; //4 bytes
    A(int n)
    {
        p = new int[n];
    }  
};

int main()
{
    A x1(10);   
    A x2(100);  
    cout << boolalpha << (sizeof(x1) == sizeof(x2)); //prints true
}

The reason is that A only contains a pointer. The size of the pointer is always the same (usually 4). It doesn't matter what the pointer points to - a dynamic array of 1000 or 1000000. It's still 4.

Char or double does not affect the size because a pointer to char has the same size as the pointer to double.

For an std::array, which actually holds an array, not a pointer, these would matter (both the array type and size):

cout << boolalpha << ((sizeof(std::array<int, 10>) == sizeof(std::array<int, 11>)); //false!
cout << boolalpha << ((sizeof(std::array<int, 10>) == sizeof(std::array<long double, 10>)); //false!

score 2 · Answer 4 · answered Jul 04 '13 at 14:37

It's important to remember that sizeof is evaluated at compile time: so it is not, in any sense, dynamic.

Its job is to return the size of the class / structure / plain old data; nothing else.

That is why it always gives the same results for your vectors, sets and maps.

score 2 · Answer 5 · answered Jul 04 '13 at 14:46

You seem to be assuming that the size of a container class can increase with the number of elements consumed, but this is physically impossible as all types have a fixed size.

Instead, elements are stored indirectly using dynamic allocation;
sizeof will not reveal this information to you.

The only information that sizeof gives you is how many pointers, counters, flags and other metadata are used in the construction and management of the container; this sort of detail is abstracted away from you and you should never attempt to rationalise about it.

sizeof() on C++ Standard Library

5 Answers5