算法竞赛中C++ stringstream终极指南

1. stringstream的基本概念与类继承关系

1.1 标准库中的定位

stringstream 是C++标准库 <sstream> 头文件中定义的字符串流类，它继承自 iostream 体系，提供了基于内存的字符串输入输出功能。在算法竞赛中，它是处理复杂字符串解析的利器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <sstream>
#include <iostream>
using namespace std;

// 类继承关系图
/*
    ios_base
       ↑
      ios
       ↑
    istream ←----- iostream ←----- stringstream
       ↑              ↑
    istringstream   ostringstream
*/

1.2 三种字符串流类型

类名 用途 竞赛场景
istringstream 输入字符串流 解析字符串到变量
ostringstream 输出字符串流 格式化输出到字符串
stringstream 双向字符串流 同时支持读写操作

2. 字符串流操作的核心方法

2.1 str() - 获取/设置底层字符串

str() 方法是stringstream的核心接口，用于访问和修改底层字符串内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <sstream>
#include <iostream>
using namespace std;

void demonstrate_str_method() {
    // 1. 获取底层字符串
    stringstream ss("Hello World 123");
    string content = ss.str();  // 获取: "Hello World 123"
    cout << "Content: " << content << endl;
    
    // 2. 设置底层字符串（重置流）
    ss.str("New content 456");
    string word;
    ss >> word;  // 读取第一个单词
    cout << "First word: " << word << endl;  // "New"
    
    // 3. 清空内容
    ss.str("");  // 清空底层字符串
    cout << "Empty check: " << (ss.str().empty() ? "Empty" : "Not empty") << endl;
}

2.2 clear() - 重置流状态

clear() 用于重置流的错误状态标志，在重复使用stringstream时至关重要。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void demonstrate_clear_method() {
    stringstream ss;
    
    // 场景1：读取失败后的状态重置
    ss << "123abc";
    int num;
    ss >> num;  // 成功读取123
    cout << "Read num: " << num << endl;
    cout << "EOF before: " << (ss.eof() ? "Yes" : "No") << endl;
    
    // 场景2：重置后继续读取
    ss.clear();  // 清除EOF标志
    string rest;
    ss >> rest;  // 读取"abc"
    cout << "Rest content: " << rest << endl;
    
    // 场景3：错误状态处理
    ss.str("not_a_number");
    ss >> num;  // 转换失败，设置fail标志
    cout << "Fail state: " << (ss.fail() ? "Yes" : "No") << endl;
    ss.clear();  // 清除fail标志
    cout << "After clear: " << (ss.fail() ? "Yes" : "No") << endl;
}

2.3 流式操作符重载

2.3.1 operator<< - 输出操作符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void demonstrate_output_operator() {
    stringstream ss;
    
    // 基本类型输出
    ss << 42 << " " << 3.14 << " " << "Hello";
    cout << "Formatted: " << ss.str() << endl;  // "42 3.14 Hello"
    
    // 格式化控制
    ss.str("");  // 清空
    ss << setw(5) << setfill('0') << 42;  // 宽度5，填充0
    cout << "Padded: " << ss.str() << endl;  // "00042"
    
    // 科学计数法
    ss.str("");
    ss << scientific << 1234.567;
    cout << "Scientific: " << ss.str() << endl;  // "1.234567e+03"
}

2.3.2 operator>> - 输入操作符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void demonstrate_input_operator() {
    stringstream ss("123 45.67 Hello World");
    
    // 连续读取
    int num;
    double real;
    string word1, word2;
    
    ss >> num >> real >> word1 >> word2;
    cout << "Parsed: " << num << ", " << real << ", " << word1 << ", " << word2 << endl;
    
    // 处理读取失败
    ss.str("123 abc");
    ss >> num;
    if (ss.fail()) {
        cout << "Conversion failed" << endl;
        ss.clear();  // 清除错误状态
    }
}

3. 算法竞赛中的典型应用场景

3.1 字符串与数值类型的高效转换

3.1.1 数值转字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 高效数值转字符串模板
template<typename T>
string numberToString(T value) {
    stringstream ss;
    ss << value;
    return ss.str();
}

// 竞赛实用示例
void numberToStringExamples() {
    // 整数转字符串
    int score = 987654;
    string scoreStr = numberToString(score);
    
    // 浮点数转字符串（控制精度）
    double pi = 3.141592653589793;
    stringstream ss;
    ss << fixed << setprecision(6) << pi;
    string piStr = ss.str();  // "3.141593"
    
    // 科学计数法
    ss.str("");
    ss << scientific << setprecision(2) << 1234567.89;
    string scientificStr = ss.str();  // "1.23e+06"
}

3.1.2 字符串转数值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 安全字符串转数值模板
template<typename T>
bool stringToNumber(const string& str, T& value) {
    stringstream ss(str);
    ss >> value;
    return !ss.fail() && ss.eof();  // 确保整个字符串都被解析
}

// 竞赛实用示例
void stringToNumberExamples() {
    // 基本转换
    string numStr = "12345";
    int num;
    if (stringToNumber(numStr, num)) {
        cout << "Parsed: " << num << endl;
    }
    
    // 处理多个数值
    string data = "100 200 300.5";
    stringstream ss(data);
    int a, b;
    double c;
    ss >> a >> b >> c;
    cout << "Values: " << a << ", " << b << ", " << c << endl;
}

3.2 复杂字符串的解析与格式化处理

3.2.1 自定义分隔符解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <sstream>
#include <vector>

// 通用分隔符分割函数
vector<string> splitString(const string& str, char delimiter) {
    vector<string> tokens;
    stringstream ss(str);
    string token;
    
    while (getline(ss, token, delimiter)) {
        if (!token.empty()) {  // 跳过空token
            tokens.push_back(token);
        }
    }
    return tokens;
}

// 竞赛应用示例
void parseComplexData() {
    // 解析CSV格式数据
    string csv = "Alice,25,Engineering,95.5";
    vector<string> info = splitString(csv, ',');
    
    cout << "Name: " << info[0] << endl;
    cout << "Age: " << info[1] << endl;
    
    // 解析路径数据
    string path = "/home/user/docs/file.txt";
    vector<string> pathParts = splitString(path, '/');
    
    // 解析坐标点
    string points = "(1,2) (3,4) (5,6)";
    stringstream ss(points);
    vector<pair<int, int>> coordinates;
    
    char ch;
    int x, y;
    while (ss >> ch >> x >> ch >> y >> ch) {  // 解析(x,y)格式
        coordinates.emplace_back(x, y);
    }
}

3.2.2 格式化输出构建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 构建表格格式输出
string buildTable(const vector<vector<string>>& data) {
    stringstream ss;
    ss << setw(10) << left << "Name" 
       << setw(5) << right << "Age" 
       << setw(10) << right << "Score" << endl;
    ss << string(25, '-') << endl;
    
    for (const auto& row : data) {
        ss << setw(10) << left << row[0]
           << setw(5) << right << row[1]
           << setw(10) << right << row[2] << endl;
    }
    return ss.str();
}

// 构建JSON格式字符串（简化版）
string buildJSON(const map<string, string>& data) {
    stringstream ss;
    ss << "{";
    bool first = true;
    for (const auto& [key, value] : data) {
        if (!first) ss << ", ";
        ss << "\"" << key << "\": \"" << value << "\"";
        first = false;
    }
    ss << "}";
    return ss.str();
}

3.3 配合getline实现多行输入的分割处理

3.3.1 处理多行输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <sstream>
#include <vector>

// 处理多行测试数据
void processMultiLineInput() {
    int n;
    cin >> n;
    cin.ignore();  // 忽略换行符
    
    vector<vector<int>> testCases;
    for (int i = 0; i < n; i++) {
        string line;
        getline(cin, line);
        
        stringstream ss(line);
        vector<int> numbers;
        int num;
        while (ss >> num) {
            numbers.push_back(num);
        }
        testCases.push_back(numbers);
    }
}

// 处理结构化输入
struct Student {
    string name;
    int age;
    vector<int> scores;
};

Student parseStudentData(const string& line) {
    Student s;
    stringstream ss(line);
    
    ss >> s.name >> s.age;
    int score;
    while (ss >> score) {
        s.scores.push_back(score);
    }
    return s;
}

3.3.2 混合输入处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 处理数字和字符串混合输入
void processMixedInput() {
    string line;
    while (getline(cin, line)) {
        stringstream ss(line);
        
        string command;
        ss >> command;
        
        if (command == "ADD") {
            int x, y;
            ss >> x >> y;
            cout << "Sum: " << (x + y) << endl;
        } else if (command == "STRING") {
            string str;
            ss >> str;
            cout << "Length: " << str.length() << endl;
        }
    }
}

4. 性能优化技巧

4.1 避免频繁创建销毁对象

4.1.1 对象复用策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class StringStreamPool {
private:
    static stringstream reusable_ss;
    
public:
    static stringstream& getInstance() {
        reusable_ss.str("");  // 清空内容
        reusable_ss.clear();  // 重置状态
        return reusable_ss;
    }
};

stringstream StringStreamPool::reusable_ss;

// 使用示例
void optimizedNumberConversion() {
    stringstream& ss = StringStreamPool::getInstance();
    
    // 处理大量数据转换
    vector<int> numbers = {123, 456, 789, 101112};
    vector<string> strNumbers;
    
    for (int num : numbers) {
        ss << num;
        strNumbers.push_back(ss.str());
        ss.str("");  // 为下次使用清空
        ss.clear();
    }
}

4.1.2 预分配策略

1
2
3
4
5
6
7
8
9
10
// 预分配内存避免频繁扩容
void preallocationExample() {
    stringstream ss;
    ss.str().reserve(1000);  // 预分配1KB内存
    
    // 批量处理大量数据
    for (int i = 0; i < 1000; i++) {
        ss << i << " ";
    }
}

4.2 合理复用stringstream实例

4.2.1 函数内部复用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 高效字符串转整数数组
vector<int> parseIntArray(const string& str) {
    static stringstream ss;  // 静态变量，函数间复用
    ss.str(str);
    ss.clear();
    
    vector<int> result;
    int num;
    while (ss >> num) {
        result.push_back(num);
    }
    return result;
}

// 批量处理工具
class BatchProcessor {
private:
    stringstream ss;
    
public:
    vector<string> split(const string& str, char delimiter) {
        ss.str(str);
        ss.clear();
        
        vector<string> tokens;
        string token;
        while (getline(ss, token, delimiter)) {
            if (!token.empty()) {
                tokens.push_back(token);
            }
        }
        return tokens;
    }
    
    template<typename T>
    string join(const vector<T>& elements, const string& delimiter) {
        ss.str("");
        ss.clear();
        
        for (size_t i = 0; i < elements.size(); i++) {
            if (i != 0) ss << delimiter;
            ss << elements[i];
        }
        return ss.str();
    }
};

4.3 与cin/cout的同步问题处理

4.3.1 同步问题详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <sstream>

void syncIssueExample() {
    // 问题：cin和stringstream的同步问题
    cout << "Before sync: ";
    
    // 解决方案1：关闭同步（推荐）
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    // 解决方案2：使用独立缓冲区
    stringstream ss;
    ss << "test data";
    
    // 确保stringstream独立于cin/cout
    string data;
    ss >> data;
    cout << data << endl;
}

// 竞赛中的最佳实践
class FastIO {
public:
    FastIO() {
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
    }
    
    static stringstream& getStream() {
        static stringstream ss;
        ss.str("");
        ss.clear();
        return ss;
    }
};

4.3.2 缓冲区管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 手动管理缓冲区避免内存泄漏
class BufferManager {
private:
    static char buffer[1024];
    
public:
    static stringstream createStream() {
        stringstream ss;
        ss.rdbuf()->pubsetbuf(buffer, sizeof(buffer));  // 设置缓冲区
        return ss;
    }
};

char BufferManager::buffer[1024];

5. 常见错误与调试技巧

5.1 流状态错误的处理

5.1.1 错误状态诊断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
void diagnoseStreamErrors() {
    stringstream ss("123 abc");
    
    int num;
    ss >> num;  // 成功读取123
    cout << "Good: " << (ss.good() ? "Yes" : "No") << endl;
    cout << "EOF: " << (ss.eof() ? "Yes" : "No") << endl;
    cout << "Fail: " << (ss.fail() ? "Yes" : "No") << endl;
    
    string str;
    ss >> str;  // 读取"abc"
    
    // 尝试读取更多数据
    ss >> num;  // 失败，设置failbit
    cout << "After fail - Fail: " << (ss.fail() ? "Yes" : "No") << endl;
    
    // 重置状态
    ss.clear();
    cout << "After clear - Fail: " << (ss.fail() ? "Yes" : "No") << endl;
}

// 错误处理工具类
class StreamDebugger {
public:
    static void printState(const stringstream& ss) {
        cout << "State: ";
        if (ss.good()) cout << "GOOD ";
        if (ss.eof()) cout << "EOF ";
        if (ss.fail()) cout << "FAIL ";
        if (ss.bad()) cout << "BAD ";
        cout << endl;
    }
    
    static bool safeRead(stringstream& ss, int& value) {
        ss >> value;
        if (ss.fail()) {
            ss.clear();
            return false;
        }
        return true;
    }
};

5.2 类型转换失败的异常处理

5.2.1 安全转换模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <sstream>
#include <stdexcept>

// 安全的类型转换模板
class SafeConverter {
public:
    template<typename Target, typename Source>
    static bool convert(const Source& source, Target& target) {
        stringstream ss;
        ss << source;
        ss >> target;
        return !ss.fail() && ss.eof();
    }
    
    template<typename Target, typename Source>
    static Target convertOrDefault(const Source& source, const Target& defaultValue = Target{}) {
        Target result;
        return convert(source, result) ? result : defaultValue;
    }
    
    template<typename Target, typename Source>
    static Target convertOrThrow(const Source& source) {
        Target result;
        if (!convert(source, result)) {
            throw invalid_argument("Conversion failed");
        }
        return result;
    }
};

// 使用示例
void safeConversionExample() {
    string str = "12345";
    int num;
    
    if (SafeConverter::convert(str, num)) {
        cout << "Safe conversion: " << num << endl;
    }
    
    // 带默认值
    string invalid = "abc";
    int safeNum = SafeConverter::convertOrDefault(invalid, 0);
    cout << "Safe with default: " << safeNum << endl;
}

5.2.2 异常安全处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// RAII风格的stringstream管理
class StreamGuard {
private:
    stringstream& ss;
    
public:
    explicit StreamGuard(stringstream& stream) : ss(stream) {}
    
    ~StreamGuard() {
        ss.str("");   // 清空内容
        ss.clear();   // 重置状态
    }
    
    // 删除拷贝构造函数
    StreamGuard(const StreamGuard&) = delete;
    StreamGuard& operator=(const StreamGuard&) = delete;
};

// 使用示例
void exceptionSafeUsage() {
    stringstream ss;
    {
        StreamGuard guard(ss);
        ss << "test data 123";
        string data;
        ss >> data;
        cout << "Processed: " << data << endl;
    }  // 自动清理
}

5.3 内存管理的注意事项

5.3.1 内存泄漏预防

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// 内存使用监控
class MemoryTracker {
private:
    static size_t peakMemory;
    
public:
    static void trackMemory(const stringstream& ss) {
        size_t current = ss.str().capacity();
        peakMemory = max(peakMemory, current);
        cout << "Current: " << current << " bytes, Peak: " << peakMemory << " bytes" << endl;
    }
    
    static void shrinkToFit(stringstream& ss) {
        string temp = ss.str();
        temp.shrink_to_fit();
        ss.str(temp);
        ss.clear();
    }
};

size_t MemoryTracker::peakMemory = 0;

// 内存优化示例
void memoryOptimizedProcessing() {
    vector<string> largeData(1000, "1234567890");
    stringstream ss;
    
    // 预分配内存
    size_t estimatedSize = 0;
    for (const auto& str : largeData) {
        estimatedSize += str.size() + 1;  // +1 for delimiter
    }
    ss.str().reserve(estimatedSize);
    
    // 处理数据
    for (const auto& str : largeData) {
        ss << str << " ";
    }
    
    MemoryTracker::trackMemory(ss);
    MemoryTracker::shrinkToFit(ss);
}

5.3.2 缓冲区溢出防护

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 安全的大小限制
class BoundedStream {
private:
    static const size_t MAX_SIZE = 1024 * 1024;  // 1MB限制
    stringstream ss;
    
public:
    bool write(const string& data) {
        if (ss.str().size() + data.size() > MAX_SIZE) {
            return false;  // 超出限制
        }
        ss << data;
        return true;
    }
    
    string readAll() {
        return ss.str();
    }
    
    void clear() {
        ss.str("");
        ss.clear();
    }
};

6. 竞赛实战案例

6.1 复杂输入解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 处理形如 "Point(x,y,z)" 的复杂输入
struct Point3D {
    double x, y, z;
    
    static Point3D parse(const string& input) {
        Point3D p;
        stringstream ss(input);
        
        char ch;
        ss >> ch;  // 'P'
        ss.ignore(5);  // "oint("
        ss >> p.x >> ch >> p.y >> ch >> p.z >> ch;  // x,y,z)
        
        return p;
    }
    
    string toString() const {
        stringstream ss;
        ss << "Point(" << x << "," << y << "," << z << ")";
        return ss.str();
    }
};

// 使用示例
void complexInputExample() {
    string input = "Point(3.14,2.71,1.41)";
    Point3D p = Point3D::parse(input);
    cout << "Parsed: " << p.toString() << endl;
}

6.2 数据格式转换工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
// 通用数据转换器
class DataConverter {
public:
    // 任意分隔符转vector
    template<typename T>
    static vector<T> parseVector(const string& str, char delimiter = ' ') {
        vector<T> result;
        stringstream ss(str);
        string token;
        
        while (getline(ss, token, delimiter)) {
            if (!token.empty()) {
                T value;
                stringstream token_ss(token);
                token_ss >> value;
                if (!token_ss.fail()) {
                    result.push_back(value);
                }
            }
        }
        return result;
    }
    
    // 矩阵数据解析
    static vector<vector<int>> parseMatrix(const string& str) {
        vector<vector<int>> matrix;
        stringstream ss(str);
        string line;
        
        while (getline(ss, line)) {
            vector<int> row = parseVector<int>(line);
            if (!row.empty()) {
                matrix.push_back(row);
            }
        }
        return matrix;
    }
    
    // 自定义格式化输出
    template<typename Container>
    static string formatContainer(const Container& container, 
                                 const string& separator = ", ",
                                 const string& prefix = "[",
                                 const string& suffix = "]") {
        stringstream ss;
        ss << prefix;
        
        bool first = true;
        for (const auto& item : container) {
            if (!first) ss << separator;
            ss << item;
            first = false;
        }
        
        ss << suffix;
        return ss.str();
    }
};

// 使用示例
void converterExample() {
    string data = "1,2,3,4,5";
    vector<int> numbers = DataConverter::parseVector<int>(data, ',');
    cout << "Parsed: " << DataConverter::formatContainer(numbers) << endl;
}

6.3 竞赛模板整合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// 竞赛专用stringstream工具包
class ContestUtils {
private:
    static stringstream ss;
    
public:
    // 快速读取整行整数
    static vector<int> readIntArray() {
        vector<int> result;
        string line;
        getline(cin, line);
        
        ss.str(line);
        ss.clear();
        
        int num;
        while (ss >> num) {
            result.push_back(num);
        }
        return result;
    }
    
    // 安全转换
    template<typename T>
    static T toNumber(const string& str) {
        ss.str(str);
        ss.clear();
        
        T result;
        ss >> result;
        return result;
    }
    
    // 格式化输出
    template<typename T>
    static string format(const T& value, int precision = 6) {
        ss.str("");
        ss.clear();
        ss << fixed << setprecision(precision) << value;
        return ss.str();
    }
};

stringstream ContestUtils::ss;

// 使用示例
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    // 快速读取测试用例
    vector<int> data = ContestUtils::readIntArray();
    
    // 处理数据...
    
    // 格式化输出结果
    double result = 3.141592653589793;
    cout << ContestUtils::format(result, 2) << endl;  // "3.14"
    
    return 0;
}

7. 性能对比与最佳实践

7.1 性能测试对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <chrono>
#include <sstream>

class PerformanceTester {
public:
    static void compareMethods() {
        const int iterations = 100000;
        
        // 测试1：stringstream vs to_string
        auto testStringStream = []() {
            stringstream ss;
            for (int i = 0; i < 1000; i++) {
                ss.str("");
                ss.clear();
                ss << i;
            }
        };
        
        auto testToString = []() {
            for (int i = 0; i < 1000; i++) {
                string s = to_string(i);
            }
        };
        
        cout << "stringstream: " << measureTime(testStringStream, iterations) << "ms" << endl;
        cout << "to_string: " << measureTime(testToString, iterations) << "ms" << endl;
    }
    
private:
    template<typename Func>
    static double measureTime(Func func, int iterations) {
        auto start = chrono::high_resolution_clock::now();
        for (int i = 0; i < iterations; i++) {
            func();
        }
        auto end = chrono::high_resolution_clock::now();
        return chrono::duration<double, milli>(end - start).count();
    }
};

7.2 最佳实践总结

场景 推荐做法 避免做法
单次转换 使用to_string/stoi 创建stringstream
复杂解析 复用stringstream实例 频繁创建销毁
大量数据 预分配内存 动态扩容
错误处理 检查流状态 忽略错误标志
性能敏感 关闭同步 混合使用cin/cout

8. 结论

stringstream 是算法竞赛中处理字符串的强大工具，掌握其核心方法和优化技巧能够显著提升代码质量和运行效率。通过合理使用对象复用、错误处理和性能优化策略，可以在竞赛中发挥其最大价值。

记住关键原则：简单场景用简单方法，复杂场景用stringstream，性能关键时预优化。

本文档持续更新，欢迎分享更多实战经验和优化技巧。