C++ 对指针 vector 进行排序，其中对象表示矩阵坐标

Question

我读取了一个文件，其中矩阵由 0、1 和 2 填充。 当我找到一个 1 时，我创建一个 BlueCar，当我找到 2 时，我创建 RedCar:

class BlueCar : public Car
{
    public:
        BlueCar(){};
        BlueCar(int x, int y);
        void move();
        virtual ~BlueCar();
};

---

class RedCar : public Car
{
    public:
        RedCar(){};
        RedCar(int x, int y);
        void move();
        virtual ~RedCar();
};

---

class Car
{
    public:
        Car();
        Car(int x, int y);
        virtual ~Car();
        virtual void move() = 0;

    private:
        int x,y;
};

我用这个对象填充了两个 vector :

    std::vector<BluCar*> *sparseBlu;
    std::vector<RedCar*> *sparseRed;

考虑到我需要移动矩阵的汽车，蓝色的向下移动，红色的向右移动，我认为最好的方法是对这些 vector 进行排序。这样我可以快速查看我正在考虑的汽车旁边的位置是否是空的。

由于蓝色汽车向下移动，我认为最好先按列然后按行对“sparseBlu”进行排序，而不是先按行再按列对“sparseRed”进行排序。

我怎样才能达到这个结果？ 最好(在性能方面)当我一车一车地填充时立即对 vector 进行排序，对吧？

Answer 1

简答:

std::sort(std::begin(*sparseBlu), std::end(*sparseBlu),
          [](const BlueCar* lhs, const BlueCar* rhs) -> bool {
              return lhs->get_x() < rhs->get_x() ||
                     (lhs->get_x() == rhs->get_x() && lhs->get_y() < rhs->get_y());
          });

std::sort(std::begin(*sparseRed), std::end(*sparseRed),
          [](const RedCar* lhs, const RedCar* rhs) -> bool {
              return lhs->get_y() < rhs->get_y() ||
                     (lhs->get_y() == rhs->get_y() && lhs->get_x() < rhs->get_x());
          });

请重新考虑，如果使用指针确实是您在这里需要的。没有指针，噪音就会减少。

std::vector<BluCar> sparseBlu;
std::vector<RedCar> sparseRed;

std::sort(std::begin(sparseBlu), std::end(sparseBlu),
          [](const BlueCar& lhs, const BlueCar& rhs) -> bool {
              return lhs.get_x() < rhs.get_x() ||
                     (lhs.get_x() == rhs.get_x() && lhs.get_y() < rhs.get_y());
          });

std::sort(std::begin(sparseRed), std::end(sparseRed),
          [](const RedCar& lhs, const RedCar& rhs) -> bool {
              return lhs.get_y() < rhs.get_y() ||
                     (lhs.get_y() == rhs.get_y() && lhs.get_x() < rhs.get_x());
          });

当这种顺序在您的应用程序中很自然时，您还可以考虑重载 operator < () .这使得调用 sort()更明确:

std::sort(std::begin(sparseBlu), std::end(sparseBlu), std::less<BlueCar>);
std::sort(std::begin(sparseRed), std::end(sparseRed), std::less<RedCar>);

几乎是声明式的编程风格。

如果您出于某种原因决定坚持使用指针，请考虑使用 std::unique_ptr<>或 std::shared_ptr<>而不是原始指针，以正确管理对象的生命周期。请记住，C++ 中没有垃圾收集。