c++ native更高性能的动态字符串处理【动态topic或者动态索引处理】

[shalousun]

这个一个仿照golang版本的动态字符处理的版本，当前似乎是执行速度比较快的方式。

FormatEvaler.h
#pragma once
#include <string>
#include <map>
#include <memory>
#include <vector>
#include <functional>

// 占位符操作符（这里预留，可扩展 %{key|upper} 等）
struct VariableOp {
    std::string opName;
};

class FormatEvaler {
public:
    virtual ~FormatEvaler() = default;
    virtual std::string evaluate(const std::map<std::string, std::string>& fields) const = 0;
    virtual void collectKeys(std::vector<std::string>& keys) const = 0;
};

class StringElement : public FormatEvaler {
public:
    StringElement(const std::string& v, bool isVar);
    std::string evaluate(const std::map<std::string, std::string>& fields) const override;
    void collectKeys(std::vector<std::string>& keys) const override;

private:
    std::string value;
    bool isVariable;
};

class CompiledFormat {
public:
    void addPart(std::unique_ptr<FormatEvaler> part);
    std::string run(const std::map<std::string, std::string>& fields) const;
    std::vector<std::string> collectKeys() const;

private:
    std::vector<std::unique_ptr<FormatEvaler>> parts;
};

std::vector<std::string> compileKeys(const std::string& format);

std::unique_ptr<CompiledFormat> compile(
    const std::string& format,
    std::function<std::unique_ptr<FormatEvaler>(const std::string&, const std::vector<VariableOp>&)> resolver);

cpp

#include "FormatEvaler.h"
#include <regex>
#include <stdexcept>
#include <algorithm>
#include <cstdlib>
#include <iostream>

// -------------------- StringElement --------------------
StringElement::StringElement(const std::string& v, bool isVar)
    : value(v), isVariable(isVar) {}

std::string StringElement::evaluate(const std::map<std::string, std::string>&) const {
    return value;
}

void StringElement::collectKeys(std::vector<std::string>& keys) const {
    if (isVariable) {
        keys.push_back(value);
    }
}

// -------------------- EnvVarElement --------------------
class EnvVarElement : public FormatEvaler {
public:
    explicit EnvVarElement(const std::string& varName) : name(varName) {}

    std::string evaluate(const std::map<std::string, std::string>&) const override {
        if (const char* val = std::getenv(name.c_str())) {
            return std::string(val);
        } else {
            std::cerr << "[Warning] Environment variable not found: " << name << '\n';
            return "";
        }
    }

    void collectKeys(std::vector<std::string>&) const override {
        // 环境变量不加入 fields key 集合
    }

private:
    std::string name;
};

// -------------------- CompiledFormat --------------------
void CompiledFormat::addPart(std::unique_ptr<FormatEvaler> part) {
    parts.push_back(std::move(part));
}

std::string CompiledFormat::run(const std::map<std::string, std::string>& fields) const {
    std::string result;
    for (const auto& part : parts) {
        result += part->evaluate(fields);
    }
    return result;
}

std::vector<std::string> CompiledFormat::collectKeys() const {
    std::vector<std::string> keys;
    for (const auto& part : parts) {
        part->collectKeys(keys);
    }
    return keys;
}

// -------------------- compileKeys --------------------
std::vector<std::string> compileKeys(const std::string& format) {
    std::vector<std::string> keys;
    // 只匹配 %{name}
    const std::regex field_regex(R"(\%\{([^}]+)\})");
    std::smatch matches;

    std::string remaining = format;
    while (std::regex_search(remaining, matches, field_regex)) {
        keys.push_back(matches[1].str());
        remaining = matches.suffix().str();
    }

    // 去重
    std::ranges::sort(keys);
    keys.erase(std::ranges::unique(keys).begin(), keys.end());

    return keys;
}

// -------------------- compile --------------------
std::unique_ptr<CompiledFormat> compile(
    const std::string& format,
    std::function<std::unique_ptr<FormatEvaler>(const std::string&, const std::vector<VariableOp>&)> resolver)
{
    auto compiled = std::make_unique<CompiledFormat>();
    std::regex var_regex(R"((\%\{|\$\{)([^}]+)\})"); // group1=前缀，group2=变量名
    std::smatch matches;

    std::string remaining = format;
    while (std::regex_search(remaining, matches, var_regex)) {
        // 前面的普通文本
        if (matches.position() > 0) {
            compiled->addPart(std::make_unique<StringElement>(
                remaining.substr(0, matches.position()), false));
        }

        std::string prefix = matches[1].str();
        std::string key    = matches[2].str();

        if (prefix == "%{") {
            // 从 fields 取值
            std::vector<VariableOp> ops;
            auto var_evaler = resolver(key, ops);
            if (!var_evaler) {
                throw std::runtime_error("Failed to resolve variable: " + key);
            }
            compiled->addPart(std::move(var_evaler));
        } else {
            // 从环境变量取值
            compiled->addPart(std::make_unique<EnvVarElement>(key));
        }

        remaining = matches.suffix().str();
    }

    // 剩余普通文本
    if (!remaining.empty()) {
        compiled->addPart(std::make_unique<StringElement>(remaining, false));
    }

    return compiled;
}

测试运行100万次

#include "FormatEvaler.h"
#include <iostream>
#include <cassert>
#include <chrono>
#include <cstdlib> // setenv

// 测试 compileKeys 只提取 %{...}
void testCompileKeys() {
    std::string format = "kafka_%{app_name}_${USER}";
    std::vector<std::string> expected = {"app_name"};
    auto keys = compileKeys(format);
    assert(keys == expected);
    std::cout << "[CompileKeys] ✅ Passed. Keys: ";
    for (auto& k : keys) std::cout << k << " ";
    std::cout << "\n";
}

// 测试 compile + run
void testCompileRun() {
    std::string format = "kafka_%{app_name}_${USER}";
    std::map<std::string, std::string> fields{{"app_name", "ilogtail"}};

    // 设置环境变量
    setenv("USER", "alice", 1);

    auto cf = compile(format, [&fields](const std::string& key, const std::vector<VariableOp>&) {
        auto it = fields.find(key);
        if (it != fields.end()) {
            return std::make_unique<StringElement>(it->second, false);
        }
        return std::make_unique<StringElement>(key, true);
    });

    auto result = cf->run(fields);
    assert(result == "kafka_ilogtail_alice");
    std::cout << "[CompileRun] ✅ Passed. Result: " << result << "\n";
}

// 性能测试
void benchmarkPerformance() {
    const int iterations = 1'000'000;
    std::string format = "kafka_%{app_name}_%{age}_%{username}_${USER}";
    std::map<std::string, std::string> fields{
        {"app_name", "ilogtail"},
        {"age", "25"},
        {"username", "bob"},

    };

    // 设置环境变量
    setenv("USER", "alice", 1);

    // 编译一次（模拟实际使用：编译一次，运行百万次）
    const auto cf = compile(format, [&fields](const std::string& key, const std::vector<VariableOp>&) {
        if (const auto it = fields.find(key); it != fields.end()) {
            return std::make_unique<StringElement>(it->second, false);
        }
        return std::make_unique<StringElement>(key, true);
    });

    // 预热一次
    const auto result = cf->run(fields);
    std::cout << "[Init] format string: " << result << "\n";

    // 开始计时
    const auto start = std::chrono::high_resolution_clock::now();

    // 执行 100 万次格式化
    for (int i = 0; i < iterations; ++i) {
        const volatile auto result = cf->run(fields); // volatile 防止被编译器优化掉
        (void)result;
    }

    // 结束计时
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

    // 计算性能指标
    double elapsed_seconds = duration.count() / 1000.0; // 毫秒转秒
    double opsPerSec = iterations / elapsed_seconds;   // 吞吐量（次/秒）
    double avgLatencyUs = elapsed_seconds * 1'000'000 / iterations; // 平均延迟（微秒/次）

    // 统一输出格式
    std::cout << "[性能测试] ✅\n"
              << "执行 " << iterations << " 次格式化\n"
              << "总耗时: " << elapsed_seconds << " 秒\n"
              << "吞吐量: " << static_cast<int>(opsPerSec) << " 次/秒\n"
              << "平均延迟: " << avgLatencyUs << " 微秒/次\n\n";
}

int main() {
    testCompileKeys();
    testCompileRun();
    benchmarkPerformance();
    std::cout << "🎉 All tests passed!\n";
    return 0;
}

@ChaoEcho 可以验证对比下