这道题从一段代码开始，只是因为我觉得这样更容易看出我在追求什么:

/*static*/ 
void 
Url::Split
(std::list<std::string> & url
, const std::string& stringUrl
)
{
    std::string collector;
    collector.reserve(stringUrl.length());
    for (auto c : stringUrl)
    {
        if (PathSeparator == c)
        {
            url.push_back(collector);
            collector.clear(); // Sabotages my optimization with reserve() above!
        }
        else
        {
            collector.push_back(c);
        }
    }
    url.push_back(collector);
}

在上面的代码中，collector.reserve(stringUrl.length()); 行应该减少下面循环中执行的堆操作量。毕竟，每个子字符串都不能比整个 url 长，所以像我一样保留足够的容量看起来是个好主意。

但是，一旦子字符串完成并将其添加到 url 部分列表中，我需要以某种方式将字符串重置为长度 0。简短的“窥视定义”检查向我表明，至少在我的平台上，保留的缓冲区将被释放，这样，我的 reserve() 调用的目的就会受到损害。

在清除的情况下，它在内部调用一些 _Eos(0)。

我也可以用 collector.resize(0) 完成同样的事情，但偷看定义显示它也在内部调用 _Eos(newsize)，所以行为是一样的就像调用 clear() 一样。

现在的问题是，是否有一种可移植 的方法来建立预期的优化以及哪个std::string 函数可以帮助我实现这一点。

当然我可以写 collector[0] = '\0'; 但我觉得这很不对劲。

旁注:虽然我发现了类似的问题，但我认为这与其中任何一个都不重复。

提前致谢。

最佳答案

在 C++11 标准中，clear 是根据 erase 定义的，它被定义为值替换。没有明显的保证缓冲区没有被释放。它可能在那里，隐含在其他东西中，但我没有找到任何这样的东西。

如果没有正式保证 clear 不会释放，并且看起来至少从 C++11 开始它不存在，您有以下选择:

• 忽略这个问题。
  毕竟，动态缓冲区分配所产生的微秒可能是绝对无关紧要的，此外，即使没有正式保证，clear 释放的机会也非常低。

• 需要 clear 不释放的 C++ 实现。
  (您可以为此效果添加一个断言，检查.capacity()。)

• 做你自己的缓冲区实现。

即使在分配(如果执行)时间紧迫的情况下，忽略该问题似乎也是安全的，因为使用常见的实现 clear 不会减少容量。 p>

例如，这里以g++和Visual C++为例:

#include <iostream>
#include <string>
using namespace std;

auto main() -> int
{
    string s = "Blah blah blah";
    cout << s.capacity();
    s.clear();
    cout << ' ' << s.capacity() << endl;
}

C:\my\so\0284>g++ keep_capacity.cpp -std=c++11

C:\my\so\0284>a
14 14

C:\my\so\0284>cl keep_capacity.cpp /Feb
keep_capacity.cpp

C:\my\so\0284>b
15 15

C:\my\so\0284>_

Doing your own buffer management, if you really want to take it that far, can be done as follows:

#include <iostream>
#include <string>
#include <vector>

namespace my {
    using std::string;
    using std::vector;

    class Collector
    {
    private:
        vector<char>    buffer_;
        int             size_;

    public:
        auto str() const
            -> string
        { return string( buffer_.begin(), buffer_.begin() + size_ ); }

        auto size() const -> int { return size_; }

        void append( const char c )
        {
            if( size_ < int( buffer_.size() ) )
            {
                buffer_[size_++] = c;
            }
            else
            {
                buffer_.push_back( c );
                buffer_.resize( buffer_.capacity() );
                ++size_;
            }
        }

        void clear() { size_ = 0; }

        explicit Collector( const int initial_capacity = 0 )
            : buffer_( initial_capacity )
            , size_( 0 )
        { buffer_.resize( buffer_.capacity() ); }
    };

    auto split( const string& url, const char pathSeparator = '/' )
        -> vector<string>
    {
        vector<string>  result;
        Collector       collector( url.length() );

        for( const auto c : url )
        {
            if( pathSeparator == c )
            {
                result.push_back( collector.str() );
                collector.clear();
            }
            else
            {
                collector.append( c );
            }
        }
        if( collector.size() > 0 ) { result.push_back( collector.str() ); }
        return result;
    }
}  // namespace my

auto main() -> int
{
    using namespace std;
    auto const url = "http://en.wikipedia.org/wiki/Uniform_resource_locator";

    for( string const& part : my::split( url ) )
    {
        cout << '[' << part << ']' << endl;
    }
}

关于c++ - std::string::reserve() 和 std::string::clear() 难题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30518810/