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,'\0');

                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保持完全相同。考虑到std::string的析构函数几乎是微不足道的，strung可以做什么来实现这种快速释放。

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

我希望我的释放速度很快，那么我要做的是如何实现类似的释放速度呢？

Answer 1

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

您的strung 始终动态分配字符串。这意味着它的析构函数将始终解除分配。 std::string，如果足够小，也不会这样做。

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

1 个答案: