c++ - 在不重新分配的情况下重用字符串流

Question

我正在尝试弄清楚如何重用 stringstream 对象，而无需在每次将内容放入流中时重新分配底层字符串。我找到了 this answer这导致我这样做:

int main() {

        stringstream ss;
        int x;
        ss << "423";
        ss >> x; // x is now 423

        ss.clear();
        ss.seekg(0);
        ss.seekp(0);

        ss << "1";
        ss >> x; // x is now 123. Instead I want x to be 1.

        std::cout << x << std::endl;
}

不幸的是，这不起作用，因为第一次传递的字符串内容仍然存在(第一次传递后字符串是 "423"，第二次传递后它们是 “123”)。但是，如果我在第二次放置之后立即添加一个空格，事情似乎就可以正常工作，如下所示:

int main() {

        stringstream ss;
        int x;
        ss << "423";
        ss >> x; // x is now 423

        ss.clear();
        ss.seekg(0);
        ss.seekp(0);

        ss << "1";
        ss << " "; // add a space right after the desired value
        ss >> x; // x is now 1

        std::cout << x << std::endl;
}

在第二遍之后，字符串是 "1 3"。我对 I/O 库不是很熟悉，我想知道上述方法是否安全，或者它是否恰好适用于这个简单的示例，或者是否有更好的解决方案。直播码here .谢谢!

Answer 1

我用这段代码使用 clang 做了一些调查和实验:

测试代码

class LogHelper {
public:
    ~LogHelper() {
        std::cout << out.str() << '\n';
    }

    std::ostream &stream() {
        return out;
    }

private:
    std::ostringstream out;
};

#define LOG() LogHelper().stream() << __FUNCTION__ << '(' << __LINE__ << ")"
#define VAR(x) ", " #x "[" << x << ']'

class MyAllocator : public std::allocator<char> {
public:
    using base = allocator<value_type>;
    using base::allocator;

    value_type* allocate( std::size_t n, const void * hint) {
        LOG() << VAR(n);
        return base::allocate(n, hint);
    }

    value_type* allocate( std::size_t n ) {
        LOG() << VAR(n);
        return base::allocate(n);
    }

    void deallocate( value_type* p, std::size_t n ) {
        LOG() << VAR(n);
        base::deallocate(p, n);
    }
};

using MySStream = std::basic_stringstream<char, std::char_traits<char>, MyAllocator>;
using MyString = std::basic_string<char, std::char_traits<char>, MyAllocator>;

int main() {
    MySStream ss; // (MyString(255, '\0'));
    ss.clear();

    int x;
    ss << "423";
    ss << " 423";

    LOG();
    ss << " 423jlfskdfjl jfsd sdfdsfkdf dsfg dsfg dfg dfg dsfg df gdf gdfg dsfg dsfgdsfgds";
    LOG();
    ss >> x;

    ss.clear();
    ss.str({});

    ss.seekg(0);
    ss.seekp(0);

    ss << "1";
    ss >> x;

    std::cout << x << std::endl;
    LOG();

    return 0;
}

• 你的渴望分配的例子clang , visual studio , gcc 7.3 ignores custom allocator , gcc 8.x do not compile

main(55)
allocate(34), n[48]
allocate(34), n[96]
deallocate(39), n[48]
main(57)
1
main(70)
deallocate(39), n[96]

• 在流中预设长字符串clang , visual studio

allocate(34), n[256]
allocate(34), n[256]
deallocate(39), n[256]
main(55)
main(57)
1
main(70)
deallocate(39), n[256]

我有几个发现

1. clang 和 visual 的行为相同，gcc 对此代码有一些奇怪的问题。
2. std::basic_stringstream 字符串缓冲区总是增长，从不收缩
3. std::basic_stringstream 糟透了。您不能保留字符串大小或缓冲区大小，例如 std::string。自定义分配器只能按类型传递，不能按对象提供分配器。
4. 要减少分配，您必须在开始时设置大字符串，然后在您不成功之前不会发生容量重新分配(第二个示例)。
5. 提供自定义分配器并没有多大帮助，而且在获取结果字符串时会添加样板代码。在我的示例中，它主要用于记录分配和释放。
6. ss.str({}); 不引起分配。这里小字符串优化有帮助

结论:

1. 您可以安全地执行 ss.str({}); 按照您链接中的建议 SO answer 并且它不会导致分配。这里小字符串优化有帮助，事实是
2. 自定义分配器不是很有用
3. 在请求时设置大的虚拟字符串是非常有效的邪恶黑客
4. 寻找替代方案应该是更好的方法(也许是提升——我没有测试过)
5. 点 1 并且您的问题表明您没有进行任何测量并且您的问题基于个人假设。