Question

如何使用std :: sort？

对自定义类中的两个向量进行排序

作为一个例子，假设我有一个包含两个向量，id和标记的类。在初始化向量之后，我想通过标记对这个类的元素进行排序，保留id中的排序顺序。

我尝试使用自定义std::sort功能执行此操作。

class Example
{
public:
    void init();
    static bool sortByMarks(const Example &lhs, const Example &rhs);
    //....other functions

private:
    vector<int> ids;
    vector<int> marks;
    //....other variables   
}
void Partition::init()
{
    ids.resize(5);
    marks.resize(5);
    for(int i=0;i<5;i++)
         ids[i]=i+1;
    marks[0]=47;marks[1]=44;marks[2]=88;marks[3]=52;marks[4]=46;
}
bool Partition::sortByMarks(const Example &lhs, const Example &rhs);
{
    return lhs.marks < rhs.marks;
}

编辑：[这是通过将Example ::添加到函数调用中来修复的]我在调用此函数时遇到问题。我尝试了以下方法：

Example e; 
sort(&e, &e, Example::sortByMarks);

示例输入：

ids : 1,2,3,4,5 marks: 47,44,88,52,46

示例输出：

ids : 2,5,1,4,3 marks: 44,46,47,52,88

感谢任何帮助！

编辑：标记向量是我想要排序的（也应该相应地更改ID）

Answer 1

我认为你不能用这样的矢量做到这一点。你需要以某种方式将ID与标记结合起来，例如使用地图，对的矢量或者像这样：

void selection_sort(){
    int size = marks.size();
    for (int i = 0; i < size - 1; i = i + 1){
        int min = i;
        for (auto j = i + 1; j < size; j = j + 1){
            if (marks[j] < marks[min]){ min = j; }
        }
        std::swap(marks[i], marks[min]);
        std::swap(ids[i], ids[min]);    // add this extra line
    }
}

或者您可以编写自己的类别：

manage_pages

Answer 2

// .h file
class MarkersDetector
{
    public:
        void sortMarkers(std::vector<cv::Point2f> &markers);
        // Other functions...
    private:
        // Other variables...
};

// .cpp file
// Function for sort the marker points
bool comparePoints(cv::Point2f point1, cv::Point2f point2)
{
    if (point1.x < point2.x)
    {
        return true;
    }
    else
    {
        if ((point1.x == point2.x) && (point1.y < point2.y))
        {
            return true;
        }
    }

    return false;
}

void MarkersDetector::sortMarkers(std::vector<cv::Point2f> &markers)
{
    std::sort(markers.begin(), markers.end(), comparePoints);
}

Answer 3

需要做两件事：

由于sortByMarks是Example的成员，您需要告诉编译器正确的范围或找不到该函数：
```
sort(e, e, Example::sortByMarks);
```
然后有一个问题，因为sortByMarks是一个普通的成员函数，而普通的成员函数需要一个隐藏的第一个参数，它是一个指向调用成员函数的实例的指针，成为函数内的this指针。您可以通过创建成员函数static：
来解决此问题
```
static bool sortByMarks(const Example &lhs, const Example &rhs);
```

还有第三个问题，那就是std::sort函数实际上赢了 sort 。您调用它的方式是告诉它对大小零的数组进行排序。

说实话，我不认为你完全解决了你的问题。我猜测你真正想要的是几个对象，每个对象都包含一个单个标记，然后对包含该标记的对象的矢量进行排序。

像

class Example
{
private:
    int mark;

public:
    Example(int m) : mark(m) {}

    int get_mark() const { return mark; }
};

bool operator<(const Example& e1, const Example& e2)
{
    return e1.get_mark() < e2.get_mark();
}

std::vector<Example> example_vector = {
    Example(5),
    Example(1),
    Example(3)
};

std::sort(std::begin(example_vector), std::end(example_vector));

使用std :: sort对自定义类C ++中的向量进行排序

3 个答案: