C++ 如何按私有字符串变量字母顺序对对象向量排序

我不知道如何通过名为VIN的成员变量之一对对象向量进行排序，该变量的数据类型为

string

。我将执行冒泡排序或选择排序。我最熟悉的是气泡排序，所以这就是我尝试的方向。但是，我知道我需要比较这两个字符串，要么让它们都是大写的，要么让它们都是小写的。请记住，字符串中也将包含数字字符

所以我的问题是： 1） 如何将字符串转换为所有小写或所有ASCII数字，以及 2） temp变量应该是什么数据类型（类的数据类型或其他数据类型）

以下是我目前掌握的（不完整）代码：

    void sortInventory(vector<Vehicle> &carList)
    {
        bool swap; 
        string temp; 
        do
        {
            swap = false;

            for (int count = 0; count < carList.size(); count++)
            {
                if (carList[count].getVIN() > carList[count + 1].getVIN())
                {
                    temp = carList[count].getVIN();                                 
                    carList[count].getVIN() = carList[count + 1].getVIN();          
                    carList[count + 1].getVIN() = temp;                      
                    swap = true;                                               
                }
            }

        } while (swap);
}

下面是我的类实现：

string Vehicle::getVIN()
{   return VIN;     }

void Vehicle::setVIN(string input)
{   VIN = input;    }

谢谢

您可以执行

std:：sort（carList.begin（）、carList.end（）、vehicleCompare）

其中

vehicleCompare

是您定义的比较函数。看见然后，可以使用大写字母，如中所示

因此，比较运算符（*）将为：

尽管当您开始复制多个成员变量时，情况可能会变得糟糕：您应该构建一个复制构造函数，并将代码更改为：

auto temp = carList[count]; //you can use Vehicle instead of auto as type
carList[count] = carList[count + 1];          
carList[count + 1] = temp;

复制构造函数将是：

Vehicle(const Vehicle& in) 
  : VIN(in.getVIN() ) 
  {}

在这一点上，您还需要string中的构造函数和空构造函数

Vehicle(std::string& inVIN) 
  : VIN(inVIN) 
  {}

Vehicle(const Vehicle& in) 
  {} //All input members get initialized through the default constructor.

---

---

（*）请注意，这种比较方法并不是最有效的，因为它使整个字符串都是大写，而前几个字符通常足以决定它们的顺序。因此，一种更有效的方法是一次将一个字符大写，并在决定是否将另一个字符大写之前进行比较。

回答问题1：您可以创建一个简单的函数，将std:：string转换为大写

void string_to_upper(string &s) {
  for(int l = 0; l < s.length(); ++l) {
     s[l] = toupper(s[l]);
  }
}

void string_至_上部（string&s）{
对于（int l=0；l

首先，您的

车辆：：getVIN（）

方法应标记为

常量

，以实现正确的常量：

string Vehicle::getVIN() const
{
    return VIN;   
}

<>请注意，在C++中，不需要重新创建轮子，从头开始重新生成排序算法（除非这是一个学习练习/编写排序代码的作业）。 您只需使用STL中实现的标准算法，并使用方便的C++11 lambda自定义比较标准，例如：

// std::vector<Vehicle> carList;

std::sort(carList.begin(), carList.end(), 
    [](const Vehicle& v1, const Vehicle& s2)
    {
        /* Code implementing custom Vehicle comparison */
    }
);

//std:：vector carList；
std:：sort（carList.begin（）、carList.end（），
[]（施工车辆和v1、施工车辆和s2）
{
/*实现自定义车辆比较的代码*/
}
);

lambda中的代码可以是这样的：

    [](const Vehicle& v1, const Vehicle& s2)
    {
        // Use stricmp() to compare strings in a case insensitive way
        return (stricmp(v1.getVIN().c_str(), v2.getVIN().c_str()) < 0);
    }

<代码>[]（施工车辆和v1、施工车辆和s2） { //使用stricmp（）以不区分大小写的方式比较字符串 返回（stricmp（v1.getVIN（）.c_str（），v2.getVIN（）.c_str（））<0）； } 您可以使用

boost:：to_upper（）

，或所示方法中的其他方法，而不是调用

stricmp（）

，例如，在StackOverflow上的此线程中：

---

这是一个非常昂贵的比较函数，通常可以在比较第一个字符后确定。@BenjaminLindley是真的，但我认为OP的级别还远没有准备好进行优化。我认为更重要的是首先向他展示如何分而治之。无论如何，我在答案上加了一条注释。

void string_to_upper(string &s) {
  for(int l = 0; l < s.length(); ++l) {
     s[l] = toupper(s[l]);
  }
}

string Vehicle::getVIN() const
{
    return VIN;   
}

// std::vector<Vehicle> carList;

std::sort(carList.begin(), carList.end(), 
    [](const Vehicle& v1, const Vehicle& s2)
    {
        /* Code implementing custom Vehicle comparison */
    }
);

    [](const Vehicle& v1, const Vehicle& s2)
    {
        // Use stricmp() to compare strings in a case insensitive way
        return (stricmp(v1.getVIN().c_str(), v2.getVIN().c_str()) < 0);
    }