Question

我有一个用户类型对象的向量，并希望按第一个字符串变量然后按第二个字符串变量对向量进行排序。

<script type="text/javascript">
  $(document).ready(function(){
    alert("here");
  })
</script>

我在主代码中有一个向量，该向量已将数据解析为取决于文件的任意数量的元素。

add_action( 'init', 'wp1232_remove_price_for_variations', 99 );

function wp1232_remove_price_for_variations() {
   global $product;

   if ( 'variable' == $product->get_type() ) {
       remove_action( 'woocommerce_single_product_summary', 'woocommerce_template_single_price', 10 );
   }
}

我的问题是2折：

1）您如何基于向量内部的变量来进行向量处理？向量应基于类中的第一个字符串（标记为a的字符串）进行排序。

2）。您将如何进一步对向量进行排序，以便对第一个字符串进行排序之后，对第二个字符串进行排序，以便输出看起来像这样（出于所有目的和目的，第二个字符串（字符串b）中的数字不是整数，而是字符串）：

class MyClass{
  private:
    string a;
    string b;
    int x;
    double y;
}

Answer 1

将a和b设为公开，然后尝试执行以下操作：

std::sort(data.begin(), data.end(), [](const MyClass& v1, const MyClass& v2) {
        return (v1.a == v2.a) ? (v1.b < v2.b) : (v1.a < v2.a);   
    });

您可以将它们设为私有，也可以使用getter来获取其价值。如ZDF所述，您也可以创建<运算符。在Myclass中添加以下内容：

MyClass {
...
public:
    bool operator<(const MyClass& v2) const {
        return (a == v2.a) ? (b < v2.b) : (a < v2.a);   
    }
}

然后像这样sort：

std::sort(data.begin(), data.end());

Answer 2

std::sort支持两种比较项目的方法： 1. bool operator<(YourClass const & lhs, YourClass const & rhs); 2.传递给std::sort

的比较器

如何对您的班级进行字典比较。使用提供此类功能的std::tuple的最佳方法：

#include <iostream>
#include <algorithm>
#include <tuple>
#include <vector>
#include <string>

struct MyClass{
    std::string a;
    std::string b;
    int x;
    double y;
    std::tuple<std::string const &, std::string const &> asTupleForComparison() const
    {
        return std::tie(a, b);
    }
};


int main() 
{ 
    std::vector<MyClass> vec = {{std::string("a"), std::string("b"), 0, 0.0}, 
                                {std::string("a"), std::string("a"), 0, 0.0}};
    std::sort(vec.begin(), vec.end(), [](MyClass const & lhs, MyClass const & rhs){
        return lhs.asTupleForComparison() < rhs.asTupleForComparison();
    });

    for (auto const & item : vec)
    {
        std::cout << item.a << " " << item.b << "\n";
    }
    return 0; 
}

要解决私有变量问题，请使用friend：

class MyClass{
    std::string a;
    std::string b;
    int x;
    double y;
    std::tuple<std::string const &, std::string const &> asTupleForComparison() const
    {
       return std::tie(a, b);
    }
    friend bool compare(MyClass const & lhs, MyClass const & lhs)
    {
        return lhs.asTupleForComparison() < rhs.asTupleForComparison();
    }
};

Answer 3

除了其他方法，您甚至可以在friend class compare内的MyClass中声明自定义比较器。

类似这样的东西：

class MyClass{
  private:
   string a;
   string b;
   int x;
   double y;
  public:
   friend class compare;
}

请查看this stackoverflow答案以获取有关如何定义自定义比较器的更多详细信息。

Answer 4

这是我的工作代码的简化版本：

MyClass.h

class MyClass{
  public:
    friend bool operator > (const MyClass& lhs, const MyClass& rhs);

  private:
    string a;
    string b;
    int x;
    double y;
}

MyClass.cpp

bool operator < (const MyClass& lhs, const MyClass& rhs){
    return (lhs.a == rhs.b) ? (lhs.b < rhs.b) : (lhs.a < rhs.b);
}

Main.cpp

int main(){
  vector<MyClass> data;  // Already filed data

  sort(data.begin(), data.end());

  return 0;
}

Answer 5

您可能会通过自定义比较器。 std::tie可能有助于创建它，因为std::tuple具有字典比较（只要可以比较其内部类型）：

std::vector<MyClass> data/* = ..*/;

auto as_tuple_a_b = [](const MyClass& c) { return std::tie(c.a, c.b); };
std::sort(data.begin(), data.end(),
          [](const MyClass& lhs, const MyClass& rhs) {
              return as_tuple_a_b (lhs) < as_tuple_a_b(rhs);
          });

如果有意义，则可以为您的类型实现operator <：

bool operator< (const MyClass& lhs, const MyClass& rhs) {
    auto as_tuple = [](const MyClass& c) { return std::tie(c.a, c.b, c.x, c.y); };
    return as_tuple (lhs) < as_tuple_a_b(rhs);
}

C ++通过类中的变量对向量进行双重排序

5 个答案: