使用myclass :: operator []（int i）

Question

对std :: list 进行排序我想根据参数对列表std :: list进行排序。例如：

class myclass 
{ 
    string name, surname; 
public: 
    myclass() {} 
    ~myclass() {} 
    string operator[](int i) 
    { 
     switch (i) 
     { 
     case 1: return name; 
     case 2: return surname; 
     } 
    } 
}; 

template <typename T> 
struct compare 
{ 
    int num; 
    indirect_compare() {} 
    indirect_compare(int i) : num(i) {} 
    ~indirect_compare() {} 
    bool operator()(T * lhs, T * rhs) { return (*lhs)[num] < (*rhs)[num]; } 
}; 

list<myclass*> lst; 
int specified_by_user; 
cin >> specified_by_user; 

//later 

lst.sort(compare<myclass>(specified_by_user)); 

它适用于我，但我不确定它是否正确。当我在结构比较中的构造函数和析构函数中添加了一些消息时，我看到构造函数仅被调用一次，但析构函数被调用了9次，我不知道为什么会发生。我试图调试这个程序来检查它，但我找不到原因。

感谢您的帮助！

Answer 1

我会尝试将运算符[]切换到比较函数对象（可能甚至使用lambda代替）。这将允许您比较不属于同一类型的属性。 （例如，如果你添加一个成员int age;

另外我会有一个事物列表，而不是指向事物的指针列表你可能会得到1个构造函数和多个删除问题，因为你不够细致的指针。

事情是这样的：

struct myclass 
{ 
    string name; 
    string surname; 
}; 

template <typename T> 
struct compare 
{ 
    int num; 
    compare() {} 
    compare(int i) : num(i) {} 
    ~compare() {} 
    bool operator()(const T & lhs, const T & rhs) { 
    switch(num) 
    { 
     case 1: return lhs->name < rhs->name; 
     case 2: return lhs->surname < rhs->surname; 
     default: throw std::logic_error(); 
    } 
    } 
}; 

list<myclass> lst; 

Answer 2

你的代码看起来不错您的解决方案是有点不寻常，但它是否适合你去为它在米尔恰·巴哈的精神，我想展现！你为你的问题提供了另一种解决方案，只是为了获得灵感：

if (specified_by_user) // sort by name 
    lst.sort(auto [](auto const & a, auto const & b){ return a.name < b.name; }); 
else // sort by surname 
    lst.sort(auto [](auto const & a, auto const & b){ return a.surname < b.surname; }); 

首先，我们决定根据哪个字段将您的类和客户端代码整理出来。其次，我们没有定义比较器结构，而是将lambdas传递给lst.sort（），它可以非常简洁地定义，内联在函数调用本身中。

这意味着字段名称和姓氏是公开的（所以lambda可以访问它们）。如果你想保持他们的私人，您可以添加干将到您的类，而不是：

string const & get_name() const { return name; } 

，并稍微改变lambda表达式：

auto [](auto const & a, auto const & b){ return a.get_name() < b.get_name(); }