为什么 std::vector::operator= 会过度分配内存？

Question

I am investigating a case where way more memory is consumed than needed. If I assign a string to an std::vector , it suddenly reserves more heap memory than needed, even though the size of the string is already known:

Here's what I broke it down to:

#include <vector>
#include <iostream>
#include <new>

void* operator new(size_t size) { 
    void * p = malloc(size); 
    std::cout << "\talloc " << size << " @ " << p; 
    return p;
} 

void operator delete(void* p) { 
    std::cout << "\t      free " << p; 
    free(p);
} 

int main() {
    {
        std::cout << std::endl << "1. Create first string:   ";
        auto s1 = std::string{"String with 20 chars"};

        std::cout << std::endl << "2. Create longer string:  ";
        auto s2 = std::string{"String with 25 characters"};

        std::cout << std::endl << "3. Copy construct:        ";
        auto s3 = s2;

        std::cout << std::endl << "4. Copy assign:           ";
        s1 = s3;

        std::cout << std::endl << "5. Leaving scope:         ";
    }
    std::cout << std::endl;
}

Result:

1. Create first string:     alloc 21 @ 0x56047f176280
2. Create longer string:    alloc 26 @ 0x56047f1762a0
3. Copy construct:          alloc 26 @ 0x56047f1762d0
4. Copy assign:             alloc 41 @ 0x56047f176300         free 0x56047f176280
5. Leaving scope:                 free 0x56047f1762d0         free 0x56047f1762a0         free 0x56047f176300

I would expect line 4 to be the same as line 3.

Why do both libstdc++ (this result) and libc++ (32/48 bytes) allocate more memory for a copy assignment than for a copy construction? In both cases, the new size is known. I can't see how one of those is more likely to require additional memory in the future.

Answer 1

I tracked it down in the basic_string implementation of libstdc++. operator=(const basic_string&) calls this->assign , which calls _M_assign , which calls _M_create with the new (minimal) and the old capacity. Here, the original capacity is doubled. A link to the exponential growth policy is included as a comment.

First, I did not understand how this is related to my example. After all, I just want to replace a value.

The growth policy for operator=(const basic_string&) makes more sense when, instead of a single assignment, you consider this code:

std::string s;
for (auto i = 100; i < 110; ++i) s = s + std::to_string(i);

Here, setting the capacity so that it is "just fitting" would violate the linear growth requirement.

To solve the memory consumption problem, I now call shrink_to_fit() on the target string.