Question

我有一个类，其中包含几个double类型的成员。

假设我需要创建一个函数，根据类中某个成员的值重新排序类对象的向量。所以：

class myClass{
    ...
    public:
       double x, y, z;
    ...
 }

void SpecialSort_x(std::vector<myClass>& vec) {
    // re-order stuff according to values of vec[i].x
    ...
}

但是现在，我希望能够进行相同的重新排序，但是根据上面代码中其他成员（y和z）的值。

除了将x的所有引用更改为y或z之外，我不想再创建两个与第一个相同的函数，而是希望创建一个单一的多态函数可以根据myClass的任何成员重新排序向量。

这样做的最佳方式是什么？

Answer 1

你可以使用std::sort，结合lambda和指向成员的指针：

#include <vector>
#include <algorithm>

class MyClass
{
public:
    double x, y, z;
};
typedef double MyClass::* Field;

void specialSort(std::vector<MyClass>& vec, Field field) 
{
    std::sort(vec.begin(), vec.end(), [field](const MyClass & a, const MyClass & b) -> bool
    {
        return a.*field < b.*field;
    });
}

int main()
{
    std::vector<MyClass> vec;
    Field member = &MyClass::x;
    specialSort(vec, member);

    return 0;
}

你还可以使用以下方法来处理排序：

template<class T>
void specialSort(std::vector<T>& vec, double T::* field)
{
    std::sort(vec.begin(), vec.end(), [field](const T& a, const T& b) -> bool
    {
        return a.*field < b.*field;
    });
}

Answer 2

我同意每个人在这里给出问题描述的建议替代方法。

但是，如果您确实需要访问在运行时选择的类成员，则可以使用指向成员的指针类型。但是，通常有一种更优雅的方式来实现你想要的效果。

例如：

#include <iostream>
#include <vector>

struct X {
    double a;
    double b;
    double c;
};

void operate_on_member(const X& x, double X::*pm)
{
    std::cout << x.*pm << '\n';
}

int main()
{
    std::vector<X> xs {
        { 1, 2, 3 },
        { 4, 5, 6 },
        { 7, 8, 9 }
    };

    for (const auto& x : xs)
        operate_on_member(x, &X::a);
    for (const auto& x : xs)
        operate_on_member(x, &X::b);
    for (const auto& x : xs)
        operate_on_member(x, &X::c);
}

排序不同的班级成员

2 个答案: