C++ 如何根据std:：tm对容器进行排序？

我需要根据

std struct tm

对象对自定义类进行排序。我想知道我是否正确地处理了这个问题，并询问有关比较功能的建议。最初，我将每个

std:：tm

成员转换为一些基本数字（如.NET

DateTime

中的

Ticks

），但我认为这可能太过分了

我不必使用

列表

，但我必须使用

容器

。不过，我更喜欢

列表

。这是我的自定义类：

class MyClass
{
public:
  std::tm _datetime;
  static bool ComparePointers(MyClass*& lhs, MyClass*& rhs);
};

bool MyClass::ComparePointers(MyClass*& lhs, MyClass*& rhs)
{
  // ??
}

这是我的主要职能：

int main()
{
   std::list<MyClass*> classes;
   MyClass* class_1 = new MyClass();  classes.push_back(class_1);
   MyClass* class_2 = new MyClass();  classes.push_back(class_2);
   MyClass* class_3 = new MyClass();  classes.push_back(class_3);

   list.sort(MyClass::ComparePointers);
}

#include <list>
#include <ctime>
#include <memory>
#include <iostream>
using namespace std;

class MyClass {
public:
    // I added a constructor to initialize _datetime just for testing.
    MyClass() {
        time_t t = time(nullptr);
        _datetime = *localtime(&t);
        _datetime.tm_sec = rand() % 60;
    }
    tm _datetime;
};

int main() {
    list<unique_ptr<MyClass>> classes;
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    // C++14: classes.push_back(make_unique<MyClass>());

    classes.sort([](unique_ptr<MyClass>& a, unique_ptr<MyClass>& b) {
        return mktime(&a->_datetime) < mktime(&b->_datetime);
    });

    for (auto const &mc : classes)
        cout << asctime(&mc->_datetime);

    return 0;
}

intmain（）
{
std：：列表类；
MyClass*class_1=新建MyClass（）；类。向后推（类_1）；
MyClass*class_2=新建MyClass（）；类。向后推（class_2）；
MyClass*class_3=新建MyClass（）；类。向后推（class_3）；
排序（MyClass:：ComparePointers）；
}

最简单的解决方案是将

std:：tm

实例转换为整数值，例如从纪元开始的秒数。在

comparePainters

函数中对两个对象执行此操作，然后比较值

另一个更复杂的方法是比较

std:：tm

的每个成员，例如年、月、日、分钟等

---

顺便说一下，比较函数的名称有误。您不是在比较指针，而是在比较时间和日期值。

最简单的解决方案是将

std:：tm

实例转换为整数值，例如从纪元开始的秒数。在

comparePainters

函数中对两个对象执行此操作，然后比较值

另一个更复杂的方法是比较

std:：tm

的每个成员，例如年、月、日、分钟等

---

顺便说一下，比较函数的名称有误。您不是在比较指针，而是在比较时间和日期值。

您可以使用

mktime

将

std:：tm

值转换为可以比较的

time

。

您可以使用

mktime

将

std:：tm

值转换为可以比较的

time

。

正如@ChristianAmmer建议的那样，您可以使用转换为进行比较。但由于，您也可以使用，而不是定义比较函数：

int main()
{
   std::list<MyClass*> classes;
   MyClass* class_1 = new MyClass();  classes.push_back(class_1);
   MyClass* class_2 = new MyClass();  classes.push_back(class_2);
   MyClass* class_3 = new MyClass();  classes.push_back(class_3);

   list.sort(MyClass::ComparePointers);
}

#include <list>
#include <ctime>
#include <memory>
#include <iostream>
using namespace std;

class MyClass {
public:
    // I added a constructor to initialize _datetime just for testing.
    MyClass() {
        time_t t = time(nullptr);
        _datetime = *localtime(&t);
        _datetime.tm_sec = rand() % 60;
    }
    tm _datetime;
};

int main() {
    list<unique_ptr<MyClass>> classes;
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    // C++14: classes.push_back(make_unique<MyClass>());

    classes.sort([](unique_ptr<MyClass>& a, unique_ptr<MyClass>& b) {
        return mktime(&a->_datetime) < mktime(&b->_datetime);
    });

    for (auto const &mc : classes)
        cout << asctime(&mc->_datetime);

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
类MyClass{
公众：
//我添加了一个构造函数来初始化_datetime，只是为了测试。
MyClass（）{
时间t=时间（nullptr）；
_datetime=*本地时间（&t）；
_datetime.tm_sec=rand（）%60；
}
tm_日期时间；
};
int main（）{
列出课程；
类。推回（唯一的ptr（新的MyClass））；
类。推回（唯一的ptr（新的MyClass））；
类。推回（唯一的ptr（新的MyClass））；
//C++14:classes.push_back（使_唯一（））；
类。排序（[]（唯一的\u ptr&a、唯一的\u ptr&b）{
返回mktime（&a->\u datetime）\u datetime）；
});
用于（自动常量和mc:类）
时间）；
返回0；
}

输出：

2018年7月9日星期一11:24:34
2018年7月9日星期一11:24:41
2018年7月9日星期一11:24:47

注1：作为C++11练习，我用的实例替换了原始指针。这样，示例代码就不再泄漏程序退出时的

MyClass

指针

注2：函数可能会修改传递的

tm

struct。如果这会导致任何问题，则可以首先复制lambda表达式中的

tm

结构

注3：我使用了函数，只是为了演示。最近的微软编译器认为它们不安全，建议使用而不是.<

---

根据@ChristianAmmer的建议，您可以使用转换为进行比较。但由于，您也可以使用，而不是定义比较函数：

int main()
{
   std::list<MyClass*> classes;
   MyClass* class_1 = new MyClass();  classes.push_back(class_1);
   MyClass* class_2 = new MyClass();  classes.push_back(class_2);
   MyClass* class_3 = new MyClass();  classes.push_back(class_3);

   list.sort(MyClass::ComparePointers);
}

#include <list>
#include <ctime>
#include <memory>
#include <iostream>
using namespace std;

class MyClass {
public:
    // I added a constructor to initialize _datetime just for testing.
    MyClass() {
        time_t t = time(nullptr);
        _datetime = *localtime(&t);
        _datetime.tm_sec = rand() % 60;
    }
    tm _datetime;
};

int main() {
    list<unique_ptr<MyClass>> classes;
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    classes.push_back(unique_ptr<MyClass>(new MyClass));
    // C++14: classes.push_back(make_unique<MyClass>());

    classes.sort([](unique_ptr<MyClass>& a, unique_ptr<MyClass>& b) {
        return mktime(&a->_datetime) < mktime(&b->_datetime);
    });

    for (auto const &mc : classes)
        cout << asctime(&mc->_datetime);

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
类MyClass{
公众：
//我添加了一个构造函数来初始化_datetime，只是为了测试。
MyClass（）{
时间t=时间（nullptr）；
_datetime=*本地时间（&t）；
_datetime.tm_sec=rand（）%60；
}
tm_日期时间；
};
int main（）{
列出课程；
类。推回（唯一的ptr（新的MyClass））；
类。推回（唯一的ptr（新的MyClass））；
类。推回（唯一的ptr（新的MyClass））；
//C++14:classes.push_back（使_唯一（））；
类。排序（[]（唯一的\u ptr&a、唯一的\u ptr&b）{
返回mktime（&a->\u datetime）\u datetime）；
});
用于（自动常量和mc:类）
时间）；
返回0；
}

输出：

2018年7月9日星期一11:24:34
2018年7月9日星期一11:24:41
2018年7月9日星期一11:24:47

注1：作为C++11练习，我用的实例替换了原始指针。这样，示例代码就不再泄漏程序退出时的

MyClass

指针

注2：函数可能会修改传递的

tm

struct。如果这会导致任何问题，则可以首先复制lambda表达式中的

tm

结构

注3：我使用了函数，只是为了演示。最近的微软编译器认为它们不安全，建议使用而不是.<

---

我想这个名字还可以。它确实比较指针，但它根据指向的时间/日期数据定义了比较，而

std:：less

提供的“默认”指针比较只关心地址。如果只定义指针之间的一个比较，那么可以将其称为

ComparePointers

。如果定义了多个变量，则可能需要

ComparePointersByTime

，

ComparePointersByWeight

等。在变量初始化过程中可能应该这样做，以免在排序过程中反复计算？我认为名称是可以的。它确实比较指针，但它根据指向的时间/日期数据定义了比较，这与仅由

std:：less

提供的“默认”指针比较不同