从自定义 class 获取对象向量中的最大元素

Question

考虑以下代码块：

template<typename Prefs> class SocialPrefNode{

public:

// Constructors & Destructor
SocialPrefNode( );
SocialPrefNode( char self, std::vector<SocialPrefNode*> pref );
SocialPrefNode( const SocialPrefNode& copy );

~SocialPrefNode( );

// Setters
void set_id( char self );

void set_pref( std::vector<SocialPrefNode*> prefs );
void set_pref( SocialPrefNode& prefs );

void set_worse( std::vector<SocialPrefNode*> wrs );
void set_worse( SocialPrefNode& wrs );

void set_indiff( std::vector<SocialPrefNode*> indiff );
void set_indiff( SocialPrefNode& indiff );

// Getters
char get_id( ){ return id; }

std::vector<SocialPrefNode*> get_preferences( ){ return preferences; }
std::vector<SocialPrefNode*> get_worse( ){ return worsethan; }
std::vector<SocialPrefNode*> get_indiff( ){ return indifference; }

// Operators
SocialPrefNode& operator=( const SocialPrefNode& copy );

private:

char id{ };

std::vector<SocialPrefNode*> preferences{ };
std::vector<SocialPrefNode*> worsethan{ };
std::vector<SocialPrefNode*> indifference{ };
};

，以及

std::vector<SocialPrefNode<char>> graph

，其中后者是通过将其元素指向彼此而构成的。

如何根据 preferences 向量的大小从 graph 中获取最大元素？

即，我想 select 来自 graph 的元素相应地 preferences' 大小，按降序排列。

我考虑过使用 std::max_element( )，但它似乎不适用于上述代码，因为我使用的是来自自定义 class 的对象向量，其中没有属性可以直接通知编译器什么被认为是向量中更大或更小的元素。

感谢您的帮助。

Answer 1

默认情况下，标准库使用operator< 来比较对象。因此，如果您的 class SocialPrefNode<T> 具有为 operator< 定义的函数或成员，那么它将自动运行。

//either:
template<typename T>
bool operator<(SocialPrefNode<T> const& lhs, SocialPrefNode<T> const& rhs);

// or
template<typename T>
class SocialPrefNode
{
    public:
    bool operator<(SocialPrefNod const& rhs) const;
};

如果这不可行，那么大多数标准库函数都允许您将比较器函数指定为最后一个参数。看max_element好像是这样https://en.cppreference.com/w/cpp/algorithm/max_element

template< class ForwardIt, class Compare >
ForwardIt max_element( ForwardIt first, ForwardIt last, Compare comp );

此处的第三个参数用于比较元素。您可以传递可以进行比较的函数、lamda 或对象。

auto m = std::max_element(std::begin(graph), std::end(graph),
                          [](auto const& lhs, auto const& rhs) -> bool
                          {
                              /* Do comparison */;
                          });

Answer 2

您可以将 std::max_element 与自定义比较函数结合使用，该函数可以根据需要比较两个对象。参见 overload #3。

#include <vector>
#include <algorithm>
#include <cassert>

class Node
{
public:
    Node(const std::vector<int>& prefs) : prefs_(prefs) {}

    size_t numPrefs() const { return prefs_.size();}

    bool operator==(const Node& rhs) const { return prefs_ == rhs.prefs_;}

private:
    std::vector<int> prefs_;
};



int main(int argc, char** argv)
{
    Node one(std::vector<int>{1});
    Node two(std::vector<int>{1,2});
    Node three(std::vector<int>{1,2,3});

    std::vector<Node> nodes{one, two, three};

    auto comparison = [](const Node& a, const Node& b)
        {
            return a.numPrefs() < b.numPrefs();
        };

    auto max = std::max_element(nodes.begin(), nodes.end(), comparison);

    assert(*max == three);
    //assert(*max == two);  //Will fail
}

从自定义 class 获取对象向量中的最大元素

Getting the max element in a vector of objects from a custom class

c++

vector

max

user-defined-types