从自定义类获取对象向量中的 max 元素

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

，后者是通过将其元素指向彼此来制作的。

如何从图中获取最大元素，即首选项向量大小的大小？

即，我想根据首选项的大小从图中按降序选择元素。

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

感谢您的帮助。

Answer 1

您可以将 std：：max_element 与自定义比较函数一起使用，该函数可以根据需要比较两个对象。 请参阅重载 #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
}

Answer 2

默认情况下，标准库使用operator<来比较对象。因此，如果您的类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 */;
});