如何实现STL容器中对象的快速释放

Question

TL/DR：在Visual Studio 2012 RC上使用发布设置进行编译时，大型std::vector<std::string>如何实现如此快速的释放？

作为练习，我编写了一个类strung，它的行为与std::string类似，实现了基本的复制和移动语义。

class strung
{
private:
    size_t length_;
    char* data_;
public:
    // -------- Constructors --------
    strung() : length_(0), data_(nullptr) {};
    strung(const char* c_str)
    {
        length_ = strlen(c_str);
        data_ = new char[length_];
        ::std::copy(c_str, c_str + length_, data_);
    };
    inline explicit strung(size_t length) : length_(length)
    {
        data_ = new char[length_];
    };
    strung(size_t length, char value) : length_(length)
    {
        data_ = new char[length_];
        ::std::fill(data_, data_ + length_, value);
    };
    // -------- Copy/move-constructors --------
    strung(const strung& old)
    {
        data_ = new char[old.length_];
        ::std::copy(old.data_, old.data_ + old.length_, data_);
        length_ = old.length_;
    };
    strung(strung&& old)
    {
        data_ = old.data_;
        length_ = old.length_;
        // Even though it is a rvalue, its destructor will still be called,
        // so we would like to prevent our data from being freed.
        old.data_ = nullptr;
    };
    // -------- Assignment operators --------
    inline strung & operator =(const strung& old)
    {
        if (this != &old)
        {
            delete[] data_;
            data_ = new char[old.length_];
            ::std::copy(old.data_, old.data_ + old.length_, data_);
            length_ = old.length_;
        }
        return *this;
    };
    strung & operator =(strung&& old)
    {
        if (this != &old)
        {
            delete[] data_;
            data_ = old.data_;
            length_ = old.length_;
            old.data_ = nullptr;
        }
        return *this;
    };
    // -------- Array operators (no bounds checking by design) --------
    inline char& operator[](size_t pos)
    {
        return data_[pos];
    };
    inline const char& operator[](size_t pos) const
    {
        return data_[pos];
    };
    // -------- Insertion operator for `ostream`s --------
    inline friend ::std::ostream &operator<<(::std::ostream &out, const strung& source)
    {
        out.write(source.data_, source.length_);
        return out;
    };
    // -------- Various functions --------
    inline const size_t length() const
    {
        return length_;
    }
    // -------- Poor man's iterators --------
    char* begin()
    {
        return data_;
    };
    char* end()
    {
        return data_ + length_;
    };
    // -------- Destructor --------
    inline ~strung()
    {
        delete[] data_;
    };
}; 

我尝试使用以下代码比较std::string和strung的性能：

double time(const std::function<void(void)> &func)
{
    using namespace std::chrono;
    auto t1 = high_resolution_clock::now(); 
    func();
    auto total = duration_cast<nanoseconds>(high_resolution_clock::now()-t1);
    return static_cast<double>(total.count()) / 1000000.;
}
template<typename T>
void test(const int num)
{
    double allocation_time, full_time;
    full_time = time([&] {
        std::vector<T> container;
        allocation_time = time([&] {
            container.reserve(num);
            for (int i=0; i < num; i++)
            {
                container.emplace_back(rand() % 10 + 1,'');
                for (char &chr : container.back())
                    chr = ('A' + rand() % ('Z' - 'A' + 1) );
            }
        });
    });
    std::cout << "Full time: " <<  full_time << " miliseconds" << std::endl 
        << "Allocation time: " << allocation_time << " miliseconds" << std::endl 
        << "Deallocation time: " << full_time - allocation_time << " miliseconds" << std::endl;
}
int main()
{
    std::cout << "-------- std::string --------" << std::endl;
    test<std::string>(500000);
    std::cout << "-------- strung --------" << std::endl;
    test<strung>(500000);
    return EXIT_SUCCESS;
}

结果是：

调试（x86-64）

-------- std::string --------
Full time: 51050.9 miliseconds
Allocation time: 1853.11 miliseconds
Deallocation time: 49197.8 miliseconds
-------- strung --------
Full time: 52404 miliseconds
Allocation time: 4886.28 miliseconds
Deallocation time: 47517.7 miliseconds

发布（x86-64）：

-------- std::string --------
Full time: 113.007 miliseconds
Allocation time: 107.006 miliseconds
Deallocation time: 6.0004 miliseconds
-------- strung --------
Full time: 47771.7 miliseconds
Allocation time: 356.02 miliseconds
Deallocation time: 47415.7 miliseconds

---

分配速度是可以理解的，因为我并没有对类进行太多优化，但分配速度更有趣。

对Debug设置的测试表明，std::string和strung的解除分配同样复杂（尽管仍然非常缓慢），但对Release设置的测试使std::string的解除分配非常非常快，而strung保持完全相同。考虑到strung的析构函数几乎是微不足道的，std::string做了什么来实现如此快速的释放。

起初，我认为std::string被优化为nop，所以根本不执行释放，但当我删除strung的析构函数时，后者仍然快得多，所以可能不是这样。

我希望我的交易速度更快，那么我该怎么做才能达到类似的交易速度呢？

Answer 1

Microsoft的std::string实现使用了一种名为"小字符串优化"的东西。这意味着std::string实际上包含一个15个字符的字符串（char[16]）。如果给它一个短于16个字符的字符串，那么它会将其存储在内部存储器中。因此，在这些情况下没有进行动态内存分配。

strung始终动态分配字符串。这意味着它的析构函数将始终解除对它的分配。如果std::string足够小，则两者都不会。