#include <sstream>  // 核心头文件
#include <iostream> // 辅助IO操作

using namespace std; // 推荐显式使用std::

// 默认构造（空字符串）
stringstream ss1;

// 从C风格字符串构造
const char* data = "天翼云对象存储";
stringstream ss2(data);

// 从std::string构造（推荐方式）
string cloud_str = "天翼云弹性计算";
stringstream ss3(cloud_str);

// 析构时自动释放资源
// 显式调用clear()可复用对象

void log_cloud_event(const string& instance_id, int status_code, double latency) {
    stringstream log_stream;
    log_stream << "[天翼云监控] 实例ID:" << instance_id 
               << " 状态码:" << status_code 
               << " 延迟:" << latency << "ms";
    
    // 实际项目中可写入天翼云日志服务
    cout << log_stream.str() << endl;
}

// 调用示例
log_cloud_event("i-123456", 200, 25.5);

#include <vector>

vector<string> parse_cdn_nodes(const string& json_fragment) {
    vector<string> nodes;
    stringstream ss(json_fragment);
    string token;
    
    // 假设格式为 "node1,node2,node3"
    while (getline(ss, token, ',')) {
        // 去除可能的空格
        size_t pos = token.find(' ');
        if (pos != string::npos) {
            token.erase(pos, 1);
        }
        nodes.push_back(token);
    }
    return nodes;
}

// 调用示例
string cdn_data = "上海节点, 北京节点, 广州节点";
auto nodes = parse_cdn_nodes(cdn_data);

struct CloudResource {
    string type;
    int count;
    double cost;
};

string generate_report(const vector<CloudResource>& resources) {
    stringstream report;
    report << "天翼云资源统计报告\n";
    report << "================================\n";
    
    for (const auto& res : resources) {
        report << left << setw(15) << res.type 
               << right << setw(8) << res.count 
               << " 台  费用: " << fixed << setprecision(2) 
               << res.cost << " 元\n";
    }
    
    return report.str();
}

// 需要包含<iomanip>头文件
// 调用示例
vector<CloudResource> res_list = {
    {"ECS", 10, 1250.50},
    {"RDS", 3, 4500.00},
    {"SLB", 2, 800.75}
};
cout << generate_report(res_list);

class CloudLogger {
    stringstream buffer;
public:
    string get_log(const string& instance, const string& message) {
        buffer.str("");  // 清空而非重建对象
        buffer.clear();  // 重置状态标志
        
        buffer << "[天翼云] " << instance << " - " 
               << current_time() << ": " << message;
        return buffer.str();
    }
    
private:
    string current_time() {
        // 实现获取当前时间逻辑
        return "2023-11-15 14:30:00";
    }
};

bool parse_cloud_config(const string& config_str, int& max_connections) {
    stringstream config_stream(config_str);
    string key;
    
    try {
        if (!(config_stream >> key) || key != "max_connections") {
            return false;
        }
        if (!(config_stream >> max_connections)) {
            return false;
        }
        // 检查剩余内容是否为空
        string remaining;
        if (getline(config_stream, remaining) && !remaining.empty()) {
            return false; // 配置项后有额外内容
        }
        return true;
    } catch (...) {
        return false; // 捕获所有异常保证安全
    }
}

#include <fstream>

void process_large_log(const string& file_path) {
    ifstream file(file_path);
    string line;
    stringstream batch_processor;
    int batch_size = 0;
    const int MAX_BATCH = 1000; // 每批处理1000条
    
    while (getline(file, line)) {
        batch_processor << line << "\n";
        if (++batch_size >= MAX_BATCH) {
            process_log_batch(batch_processor.str());
            batch_processor.str("");
            batch_processor.clear();
            batch_size = 0;
        }
    }
    
    // 处理剩余记录
    if (batch_size > 0) {
        process_log_batch(batch_processor.str());
    }
}

enum class LogType { STRUCTURED, UNSTRUCTURED };

string process_mixed_log(const string& log_entry) {
    stringstream result;
    stringstream input(log_entry);
    string type_str;
    
    input >> type_str;
    LogType type = (type_str == "[STRUCT]") ? LogType::STRUCTURED : LogType::UNSTRUCTURED;
    
    if (type == LogType::STRUCTURED) {
        string timestamp, level, message;
        input >> timestamp >> level;
        getline(input, message); // 读取剩余部分
        
        result << "天翼云结构化日志:\n"
               << "时间: " << timestamp << "\n"
               << "级别: " << level << "\n"
               << "消息: " << message.substr(1); // 跳过前导空格
    } else {
        result << "天翼云非结构化日志:\n" << log_entry;
    }
    
    return result.str();
}

string mask_secret(const string& full_secret) {
    stringstream masked;
    size_t len = full_secret.length();
    
    if (len <= 4) {
        masked << full_secret; // 过短不脱敏
    } else {
        masked << string(len-4, '*') 
               << full_secret.substr(len-4);
    }
    
    return masked.str();
}

// 使用示例
string api_key = "CTYUN-12345-ABCD-67890";
cout << "天翼云API密钥: " << mask_secret(api_key);

// boost::format示例（需额外依赖）
#include <boost/format.hpp>
string boost_example() {
    boost::format fmt("天翼云实例%1%的状态为%2%");
    fmt % "i-123" % "running";
    return fmt.str();
}

// 选型建议：
// 1. 天翼云基础服务优先使用stringstream（无额外依赖）
// 2. 复杂格式化需求可评估boost::format