C++ 具有枚举方向/类型的Bubblesort结构数组

我有一个函数sort，被传递一个结构数组

结构包含字符串

struct studentStruct {                                                                                                                      
  string firstName;
  string lastName;
  int grade;
  float GPA;
};

我将这个结构数组传递给一个排序函数，以及两个枚举类型

enum sortField {eFirstName, eLastName, eGrade, eGPA};                                                                                                   
enum sortDirection {eAscending, eDescending};

现在，我必须使用Bubblesort和compData函数

void sort( studentStruct s[], enum sortField field, int length, sortDirection d)
{
  for(int i = 0; i < length - 1; i++)
    {
      for(int j = 0; j < length - 1 - i; j++)
        {
          if(compData(s[j], s[j+1], field, d) == true)
            {
              swap(s[j], s[j+1]);
              cout << "SWAP" << endl;
            }
        }
    }
}
bool compData( studentStruct s1, studentStruct s2,  sortField field, sortDirection direction)
{
  switch(field)
    {
    case eFirstName:
      {
        string f1 = s1.firstName;
        string f2 = s2.firstName;
        switch(direction)
          {
          case eAscending:
            {
              if(f2 < f1)
                return true;
            }
          case eDescending:
            {
              if(f2 > f1)
                return true;
            }
          }
      }
    }
}

void排序（studentStruct s[]，枚举sortField字段，int-length，sortDirection d）
{
对于（int i=0；icout我已经为
compData
中的
else
部分条件语句添加了
return false
，并按预期工作

switch(direction)
{
    case eAscending:
    {
        if(f2 < f1)
            return true;
        else    
            return false;
    }
    case eDescending:
    {
        if(f2 > f1)
            return true;
        else    
            return false;
    }
}

开关（方向）
{
案件审理：
{
if（f2f1）
返回true；
其他的
返回false；
}
}

请参阅联机。
您的比较功能大部分缺失，但其中的部分表明您没有任何路径返回确定的
false
，这对于正确的比较器是必需的

第二，您调用参数的顺序是错误的。“右”端参数应该是第一个，“左”端参数应该是第二个。如果比较器的答案为true，则它们的顺序是错误的，应该进行交换

解决这两个问题（并为您提供改进的bubblesort，对已排序的序列进行早期退出检测），结果将按预期运行：

#include <iostream>
#include <algorithm>

enum sortField {eFirstName, eLastName, eGrade, eGPA};
enum sortDirection {eAscending, eDescending};

struct studentStruct {
    std::string firstName;
    std::string lastName;
    int grade;
    float GPA;
};

bool compData( studentStruct s1, studentStruct s2, sortField field, sortDirection direction)
{
    bool result = false;

    switch(field)
    {
        case eFirstName:
            switch(direction)
            {
                case eAscending:
                    result = s1.firstName < s2.firstName;
                    break;

                case eDescending:
                    result = s2.firstName < s1.firstName;
                    break;
            }
            break;

        case eLastName:
            switch(direction)
            {
                case eAscending:
                    result = s1.lastName < s2.lastName;
                    break;

                case eDescending:
                    result = s2.lastName < s1.lastName;
                    break;
            }
            break;

        case eGrade:
            switch(direction)
            {
                case eAscending:
                    result = s1.grade < s2.grade;
                    break;

                case eDescending:
                    result = s2.grade < s1.grade;
                    break;
            }
            break;

        case eGPA:
            switch(direction)
            {
                case eAscending:
                    result = s1.GPA < s2.GPA;
                    break;

                case eDescending:
                    result = s2.GPA < s1.GPA;
                    break;
            }
            break;
    }

    return result;

}

void sort( studentStruct s[], enum sortField field, int length, sortDirection d)
{
    bool swapped = true;
    while (swapped && length-- > 0)
    {
        swapped = false;
        for (int i=0; i<length; ++i)
        {
            if (compData(s[i+1], s[i], field, d))
            {
                std::cout << "SWAP" << '\n';
                std::swap(s[i+1], s[i]);
                swapped = true;
            }
        }
    }
}

int main()
{
    studentStruct students[] = { {"M"}, {"I"}, {"K"}, {"O"}, {"N"} };
    sort(students, eFirstName, 5, eAscending);

    for (auto const& s : students)
        std::cout << s.firstName << '\n';
}

你没有收到编译器警告，因为
compData
函数没有在所有代码路径上返回任何东西吗？@Blaze我的实际程序中有剩余的开关案例，但我觉得没有必要复制粘贴到线程上，以避免出现一堆文本。我有一个开关（字段）{case eLastName:…等等，使用case efirstname中相同的copy/paste if语句愚蠢的问题：如果你传递了5个输入，为什么要传递长度
10
？仅供参考，一个实际的、真实的
main
测试用例和静态编码数据来证明这个问题会让你省去类似的问题。不仅是
compData
函数缺少您的其他案例，对于您显示的案例，它也没有可能的
return false
路径。可能您删除了太多？另外，仅供参考，如果第一个元素s1出现在第二个元素s2之前，您的
compData
将返回true。虽然这是合理的，但调用者必须传递正确的参数的顺序正确。在调用站点中，分别传递
s[j]
和
s[j+1]
。如果返回
true
，则它们的顺序已经正确。不应进行交换。您的参数是反向的。该调用应该是
If（compData（s[j+1]，s[j]，字段，d））
。如果返回为真，则意味着
j+1
索引中的元素应位于
j
中的元素之前，并且可以进行交换。非常感谢
SWAP
SWAP
SWAP
I
K
M
N
O