对多个数据成员进行排序[重复]

Question

在指针向量 (std::vector<SomeObject*) 中进行多重排序的最佳方法应该是什么？我应该为多个数据成员创建一个排序功能吗？最好的方法是什么？或者也许我应该为每个数据成员创建单独的函数？或者我应该使用std::sort() 的一些东西？ 假设我有一些带有一些数据成员的类 Vehicle

    class Vehicle{
    private:
        unsigned int _maxSpeed;
        unsigned short _numberOfHorsePower;
        unsigned short _numberOfGears;
        unsigned short _numberOfWheels;
        unsigned int _weight;
    }

我希望可以选择按每个数据成员对这些对象进行排序，例如 SortByMaxSpeedAsc(),SortByWeightAsc(),SortByWeightDesc()。

一个数据成员的示例排序

    void Vehicles::sortVehiclesByWeightAsc()
    {
        Vehicle* tmp;
        size_t n = _VehiclesCollection.size();
        int i, j, minIndex;
    
        for (i = 0; i < n - 1; i++) 
        {
            minIndex = i;
            for (j = i + 1; j < n; j++) 
            {
                if (_VehiclesCollection[j].weight < _VehiclesCollection[minIndex].weight)
                {
                    minIndex = j;
                }
            }
    
            if (minIndex != i) 
            {
                tmp = _VehiclesCollection[i];
                _VehiclesCollection[i] = _VehicleCollection[minIndex];
                _VehiclesCollection[minIndex] = tmp;
            }
    
        }
    }

Answer 1

使用std::sort 并为每个案例编写一个Compare 函子。如果需要合并多个字段，请使用std::tie。

这是一个例子。您不需要像我在这里所做的那样对static 成员进行排序，但它可以将std::tie 与私有成员一起使用。

#include <algorithm>
#include <iostream>
#include <vector>

class Vehicle {
public:
    Vehicle(unsigned maxSpeed, unsigned short numberOfHorsePower,
            unsigned short numberOfGears, unsigned short numberOfWheels,
            unsigned weight) :
        maxSpeed_(maxSpeed),
        numberOfHorsePower_(numberOfHorsePower), numberOfGears_(numberOfGears),
        numberOfWheels_(numberOfWheels), weight_(weight) {}

    // you can use the accessor functions with loose sort statements if you don't
    // need to tie many columns together

    inline unsigned get_maxSpeed() const { return maxSpeed_; }
    inline unsigned short get_numberOfHorsePower() const {
        return numberOfHorsePower_;
    }
    inline unsigned short get_numberOfGears() const { return numberOfGears_; }
    inline unsigned short get_numberOfWheels() const { return numberOfWheels_; }
    inline unsigned get_weight() const { return weight_; }

    // sorting functions

    template<typename It>
    static void sort_on_speed(It first, It last) {
        std::sort(first, last,
            // a lambda receiving references to two Vehicle objects to compare
            [](const Vehicle& a, const Vehicle& b) {
                // return true if a is less than b (using the field you want)
                return a.maxSpeed_ < b.maxSpeed_;
            }
       );
    }

    template<typename It>
    static void sort_on_hp_plus_speed(It first, It last) {
        std::sort(first, last,
            // another lambda using std::tie to sort primarily on hp
            // and secondary on speed
            [](const Vehicle& a, const Vehicle& b) {
                return std::tie(a.numberOfHorsePower_, a.maxSpeed_) <
                       std::tie(b.numberOfHorsePower_, b.maxSpeed_);
        });
    }

private:
    unsigned int maxSpeed_;
    unsigned short numberOfHorsePower_;
    unsigned short numberOfGears_;
    unsigned short numberOfWheels_;
    unsigned int weight_;
};

int main() {
    std::vector<Vehicle> cars = {
        {1, 2, 3, 4, 5}, {2, 3, 4, 5, 1}, {3, 4, 5, 1, 2}
    };

    // sort on speed
    Vehicle::sort_on_speed(cars.begin(), cars.end());

    // sort on hp + speed
    Vehicle::sort_on_hp_plus_speed(cars.begin(), cars.end());
}

Answer 2

boost.multiindex 应该很有用。