如何按给定字段对结构的向量进行分类？

Question

我需要按给定字段对结构向量进行排序。

给任何面临同样问题的人： 我只是制作了自己的排序功能，在那里您可以根据需要在lambda中传递（不仅有两个变量）。

---

在这里，我使用了lambda表达式，但是由于Lambda接受仅通过的变量，因此我无法定义要排序的字段。

sort(patients.begin(), patients.end(), [](Patient a, Patient b) { return a.name > b.name; });

我不能这样做：

string sortfield = name;
    sort(patients.begin(), patients.end(), [](Patient a, Patient b) 
{ 
   if(sortfield == "name") return a.name < b.name;
   else if(sortfield == "age") return a.age < b.age;
...
});

1. 因为它会导致错误，因为lambda只能使用经过的变量，而不是本地。
2. 很难扩展。每次我将新字段添加到结构中时，我都必须回到这里，然后再添加一个“ else”，如果“

我也尝试使用一个指针到功能会员，但它的工作方式相同。

我可以使用这样的开关案例：

enum Fields
{
    Name, Gender, DateOfBirth
};
Fields field;
switch (field)
{
case Fields::Name:
    sort(patients.begin(), patients.end(), [](Patient a, Patient b) { return a.name > b.name; });
    break;

case Fields::Gender:
    sort(patients.begin(), patients.end(), [](Patient a, Patient b) { return a.gender > b.gender; });
    break;

case Fields::DateOfBirth:
    sort(patients.begin(), patients.end(), [](Patient a, Patient b) { return a.dateOfBirth > b.dateOfBirth; });
    break;

default:
    break;
}

但是它将破坏OCP（打开封闭的原理）。当结构将扩展时，我将不得不回来几次以添加更多“情况”块。

有更好的方法吗？

Answer 1

您可以使用另一个lambda选择要比较的字段：

template <typename F>
void my_sort(auto& patients, F f) {
    sort(patients.begin(), patients.end(), [f](const Patient& a,const Patient& b) { return f(a) > f(b); });
}


my_sort(patients,[](const Patient& a) { return a.name; });

Answer 2

因为它会导致错误，因为lambda只能使用经过的变量，而不是本地。

。

这是错误的。您当然可以利用lambda中的本地变量。 捕获是方形括号的目的。

string sortfield = name;
sort(patients.begin(), patients.end(), [&sortfield](Patient a, Patient b) 
{
    if(sortfield == "name") return a.name < b.name;
    else if(sortfield == "age") return a.age < b.age;
    // ...
});

另一方面，如果修改了患者类，此方法确实会增加维护负担。如果将切换逻辑放入类中，则可以将更改本地化为类实现。 （无论您是使用字符串还是枚举取决于您，但请记住，编译器不会在字符串中捕获错别字。）

class Patient {
  public:
    enum Fields { Name, Gender, DateOfBirth };
    // For readability:
    using CompareFunction = std::function<bool(const Patient&, const Patient&)>;

    // This is a function that returns a functional. If you have not seen the
    // concept before, it might take some time to grasp the idea.
    static CompareFunction SortBy(Fields);

    // And the rest of the class definition
};

// Implementation:
Patient::CompareFunction Patient::SortBy(Fields field)
{
    switch (field)
    {
        // We are returning a lambda, which the sort function will invoke.
        case Name:        return [](const Patient &a, const Patient &b) { return a.name > b.name; };
        case Gender:      return [](const Patient &a, const Patient &b) { return a.gender > b.gender; };
        case DateOfBirth: return [](const Patient &a, const Patient &b) { return a.dateOfBirth > b.dateOfBirth; };
    }
    // ERROR! If we missed an enumerate, we should have the compiler complain.
    // Figure out what you want to do in this case.    
}

如果您想添加一个新的字段进行排序（但不是如果您添加了一个新成员，而无需选择对其进行排序）。但是，此代码与类实现有关，因此至少您不必在代码库中狩猎即可找到更新的位置。

在执行分类的代码中使用此问题：

Patient::Fields field = Patient::Name; // as an example
sort(patients.begin(), patients.end(), Patient::SortBy(field));

---

特殊情况下，如果所有潜在的排序字段具有相同的类型（对于患者而言不太可能，但对于其他情况），并且公共（在许多情况下不建议使用），然后可以使用带指针到成员的lambda代替sortby方法。这种方法的好处是，修改课程时没有特殊的维护。限制是，由于限制（相同类型和公众），通常不是一个选择。

std::string Patient::* field = &Patient::name;
sort(patients.begin(), patients.end(), [field](const Patient &a, const Patient &b) {
    return a.*field < b.*field;
});

我想，如果您使用指针来成员函数，则可以将“公共”限制得到解决。相同类型的限制可能仍然是一个障碍，语法更加混乱。

auto field = &Patient::get_name; // assuming get_name() is the getter.
sort(patients.begin(), patients.end(), [field](const Patient &a, const Patient &b) {
    return (a.*field)() < (b.*field)();
});

在这一点上，另一个答案中的“另一种lambda”方法可能是可取的（以风格为基础）。