如何在C++中对包含vector的Trade结构体按id排序？

你定义的Trade结构体将同类型交易数据分别存在三个独立向量中，排序时需要保证id、price、quantity的元素对应关系不变，以下是几种可行的实现方式：

方法一：打包成三元组排序后拆包 #

先将三组数据打包成包含完整交易信息的三元组，排序后再拆回原向量：

#include <vector>
#include <tuple>
#include <algorithm>

struct Trade {
    std::vector<long> id;
    std::vector<double> price;
    std::vector<double> quantity;
};

void sortTradeById(Trade& trade) {
    // 先校验向量长度一致性，避免越界
    if (trade.id.size() != trade.price.size() || trade.id.size() != trade.quantity.size()) {
        return; // 也可根据业务需求抛出异常
    }

    // 打包所有交易数据为三元组
    std::vector<std::tuple<long, double, double>> temp;
    temp.reserve(trade.id.size());
    for (size_t i = 0; i < trade.id.size(); ++i) {
        temp.emplace_back(trade.id[i], trade.price[i], trade.quantity[i]);
    }

    // 按id升序排序（tuple默认按第一个元素排序）
    std::sort(temp.begin(), temp.end());

    // 将排序后的数据拆回原向量
    for (size_t i = 0; i < temp.size(); ++i) {
        trade.id[i] = std::get<0>(temp[i]);
        trade.price[i] = std::get<1>(temp[i]);
        trade.quantity[i] = std::get<2>(temp[i]);
    }
}

方法二：基于索引数组排序 #

生成索引数组并按id排序，再根据索引重新排列原向量，适合数据量较大的场景（减少数据复制）：

#include <vector>
#include <algorithm>

struct Trade {
    std::vector<long> id;
    std::vector<double> price;
    std::vector<double> quantity;
};

void sortTradeById(Trade& trade) {
    if (trade.id.size() != trade.price.size() || trade.id.size() != trade.quantity.size()) {
        return;
    }

    // 创建索引数组
    std::vector<size_t> indices(trade.id.size());
    for (size_t i = 0; i < indices.size(); ++i) {
        indices[i] = i;
    }

    // 按id对应的索引排序
    std::sort(indices.begin(), indices.end(), [&trade](size_t a, size_t b) {
        return trade.id[a] < trade.id[b];
    });

    // 根据索引重新生成排序后的向量
    std::vector<long> sortedId(trade.id.size());
    std::vector<double> sortedPrice(trade.price.size());
    std::vector<double> sortedQuantity(trade.quantity.size());

    for (size_t i = 0; i < indices.size(); ++i) {
        sortedId[i] = trade.id[indices[i]];
        sortedPrice[i] = trade.price[indices[i]];
        sortedQuantity[i] = trade.quantity[indices[i]];
    }

    // 替换原向量（swap操作开销极低）
    trade.id.swap(sortedId);
    trade.price.swap(sortedPrice);
    trade.quantity.swap(sortedQuantity);
}

优化建议：重构结构体设计 #

更合理的设计是将单条交易数据封装为独立结构体，再用向量存储，排序逻辑会更简洁直观：

struct SingleTrade {
    long id;
    double price;
    double quantity;
};

// 用向量存储单条交易，替代原Trade结构体
using Trade = std::vector<SingleTrade>;

// 排序调用示例
void sortTradeById(Trade& trade) {
    std::sort(trade.begin(), trade.end(), [](const SingleTrade& a, const SingleTrade& b) {
        return a.id < b.id; // 升序排序，降序改为>即可
    });
}

注意事项 #

• 无论哪种方法，都必须先校验三个向量的长度是否一致，避免数组越界。
• 如需降序排序，只需修改排序时的比较逻辑：
  • 方法一中使用std::sort(temp.begin(), temp.end(), std::greater<std::tuple<long, double, double>>())
  • 方法二和优化方案中，将比较表达式改为trade.id[a] > trade.id[b]或a.id > b.id

内容的提问来源于stack exchange，提问作者Nicolas REY