C++ 如何使用一个函数按结构中的不同变量排序

在我的程序中，我有以下结构：

struct Record {
string ID;
string name;
int quantity;
double price; 
};

我还有一个函数，用来对指向记录的指针数组进行冒泡排序，如下所示：

void printAscending(Record* pitemList[50], int arraySize) {
  int Swap;
  Record* Temp;
  do{
    Swap = 0;
    for(int i = 0; i < (arraySize - 1); i++) {
      if ((pitemList[i] -> quantity) > (pitemList[i + 1] -> quantity)){
        Temp = pitemList[i];
        pitemList[i] = pitemList[i + 1];
        pitemList[i + 1] = Temp;
        Swap = 1;
      }
    }
  } while (Swap != 0);
}

bool compareByQuantity(const Record &a, const Record &b) {
    return a.quantity < b.quantity;
}

void打印升序（记录*pitemList[50]，整数数组化）{
国际互换；
记录*温度；
做{
交换=0；
对于（int i=0；i<（arraySize-1）；i++）{
if（（pitemList[i]->数量）>（pitemList[i+1]->数量））{
Temp=pitemList[i]；
pitemList[i]=pitemList[i+1]；
pitemList[i+1]=温度；
互换=1；
}
}
}while（Swap！=0）；
}

---

struct中有四个不同的变量，我必须让用户选择一个进行排序。我不能为每个变量创建四个不同的函数，也不能为每个变量复制和粘贴相同的冒泡排序代码四次。有没有办法用一块冒泡排序代码创建一个函数，它可以按四个不同的变量排序？

我是从头开始写的，但我认为这是正确的步骤

您需要具备以下几个功能：

void printAscending(Record* pitemList[50], int arraySize) {
  int Swap;
  Record* Temp;
  do{
    Swap = 0;
    for(int i = 0; i < (arraySize - 1); i++) {
      if ((pitemList[i] -> quantity) > (pitemList[i + 1] -> quantity)){
        Temp = pitemList[i];
        pitemList[i] = pitemList[i + 1];
        pitemList[i + 1] = Temp;
        Swap = 1;
      }
    }
  } while (Swap != 0);
}

bool compareByQuantity(const Record &a, const Record &b) {
    return a.quantity < b.quantity;
}

希望这能让你走上正轨

链接到排序文档：

正如@Ted Klein Bergman所指出的，您也可以像这样直接使用lambda

std::sort(records.begin(), records.end(), compareByQuantity);

std::sort(records.begin(), records.end(), [](const Record &a, const Record &b){ return a.quantity < b.quantity }); 

std:：sort（records.begin（），records.end（），[]（const-Record&a，const-Record&b）{返回a.quantity

我是从头开始写的，但我认为这是正确的一步

您需要具备以下几个功能：

void printAscending(Record* pitemList[50], int arraySize) {
  int Swap;
  Record* Temp;
  do{
    Swap = 0;
    for(int i = 0; i < (arraySize - 1); i++) {
      if ((pitemList[i] -> quantity) > (pitemList[i + 1] -> quantity)){
        Temp = pitemList[i];
        pitemList[i] = pitemList[i + 1];
        pitemList[i + 1] = Temp;
        Swap = 1;
      }
    }
  } while (Swap != 0);
}

bool compareByQuantity(const Record &a, const Record &b) {
    return a.quantity < b.quantity;
}

希望这能让你走上正轨

链接到排序文档：

正如@Ted Klein Bergman所指出的，您也可以像这样直接使用lambda

std::sort(records.begin(), records.end(), compareByQuantity);

std::sort(records.begin(), records.end(), [](const Record &a, const Record &b){ return a.quantity < b.quantity }); 

std:：sort（records.begin（），records.end（），[]（const-Record&a，const-Record&b）{返回a.quantity

我认为最好使用std:：sort，它让您只编写比较函数并负责排序。 您可以使用这些：

#include <algorithm>

bool compareIDs(const Record *r1, const Record *r2) { return r1->ID < r2->ID; }
bool compareNames(const Record *r1, const Record *r2) { return r1->name < r2->name; }
bool compareQuantities(const Record *r1, const Record *r2) { return r1->quantity < r2->quantity; }
bool comparePrices(const Record *r1, const Record *r2) { return r1->price < r2->price; }

// And call sort like this: std::sort(array1, array2, compareIDs);

#包括

我认为最好使用std:：sort，它让您只编写比较函数并负责排序。
您可以使用这些：

#include <algorithm>

bool compareIDs(const Record *r1, const Record *r2) { return r1->ID < r2->ID; }
bool compareNames(const Record *r1, const Record *r2) { return r1->name < r2->name; }
bool compareQuantities(const Record *r1, const Record *r2) { return r1->quantity < r2->quantity; }
bool comparePrices(const Record *r1, const Record *r2) { return r1->price < r2->price; }

// And call sort like this: std::sort(array1, array2, compareIDs);

#包括

我不知道您想要什么，但为了将代码概括为使用不同的记录成员作为比较器，我想您可以将指针作为模板参数传递给成员

您已将问题标记为，因此可以使用
auto
作为模板参数，因此：

template <auto Record::* rMember>
void printAscending (Record* pitemList[50], int arraySize)
 {
   bool Swap;

   do
    {
      Swap = false;

      for (int i = 0; i < (arraySize - 1); i++)
       {
         if ( pitemList[i]->*rMember > pitemList[i + 1]->*rMember )
          { 
            std::swap(pitemList[i], pitemList[i+1]);

            Swap = true;
          }
       }
    }
   while ( true == Swap );
 }

模板
无效打印升序（记录*pitemList[50]，整数数组化）
{
布尔交换；
做
{
交换=假；
对于（int i=0；i<（arraySize-1）；i++）
{
if（pitemList[i]->*rMember>pitemList[i+1]->*rMember）
{ 
交换（pitemList[i]，pitemList[i+1]）；
Swap=true；
}
}
}
while（true==Swap）；
}

你可以这样称呼它：

printAscending<&Record::quantity>(itemList, sizeItemList);

printsupsing（itemList，sizeItemList）；
我不确定是否理解您想要什么，但为了将您的代码概括为使用不同的记录成员作为比较器，我想您可以将指针作为模板参数传递给成员

您已将问题标记为，因此可以使用
auto
作为模板参数，因此：

template <auto Record::* rMember>
void printAscending (Record* pitemList[50], int arraySize)
 {
   bool Swap;

   do
    {
      Swap = false;

      for (int i = 0; i < (arraySize - 1); i++)
       {
         if ( pitemList[i]->*rMember > pitemList[i + 1]->*rMember )
          { 
            std::swap(pitemList[i], pitemList[i+1]);

            Swap = true;
          }
       }
    }
   while ( true == Swap );
 }

模板
无效打印升序（记录*pitemList[50]，整数数组化）
{
布尔交换；
做
{
交换=假；
对于（int i=0；i<（arraySize-1）；i++）
{
if（pitemList[i]->*rMember>pitemList[i+1]->*rMember）
{ 
交换（pitemList[i]，pitemList[i+1]）；
Swap=true；
}
}
}
while（true==Swap）；
}

你可以这样称呼它：

printAscending<&Record::quantity>(itemList, sizeItemList);

printsupsing（itemList，sizeItemList）；
为什么要使用气泡排序？“这是O（n²）@TedKleinBergman同意的，但这只能在小场景中起作用。一旦数据变得更大，它就失去了优势。如果知道集合是小的，最好的方法是对不同的算法进行配置。函数可以做<代码> STD:：SoToE（）/Cuth>算法（C++标准库的一部分）-接受一个参数，它是某种函数指针或函数对象，它指定如何比较元素。（例如，比较结构的特定成员）。为什么要使用冒泡排序？它是O（n²）TekkelnBelgman同意，但这只能帮助小集合。一旦数据变大，它就失去了优势。如果他知道集合是小的，最好的方法是对不同的算法进行配置。函数可以做<代码> STD:：SoTo（）/Cuth>算法（C++标准库的一部分）。does-接受一个参数，该参数是函数指针或函数对象的某种形式，用于指定如何比较元素（例如，比较结构的特定成员）。