QSet＜T＞自定义类型需要定义==和qHash()函数

如题，QSet<T>中T为自定义类型需要重写==函数和qHash()函数。

示例：

//
// Created by qiaowei on 2024/5/9.
//


#ifndef LORDCARD_CARD_H
#define LORDCARD_CARD_H


#include <QObject>

#include "../enums/card_suit_enum.h"
#include "../enums/card_point_enum.h"
#include "../player/player.h"


using role::Player;
using card::Card_suit_enum;
using card::Card_point_enum;


namespace card {
	
    /**
     * @copyright 2003-2024
     * @date      2024-07-21
     * @author    qiao wei
     * @version   1.0
     * @brief     扑克牌类。
     * @history   name
                  date
                  brief
     */
    class Card : public QObject {
			
        Q_OBJECT
		
        public:
            explicit Card(QObject* parent = nullptr);
		
            /**
             * @author  qiao wei
             * @brief   拷贝构造函数。
             * @param   value 被拷贝的变量。
             * @return
             * @history name
                        date
                        brief
             */
            Card(const Card& value);
			
            ~Card() override;
			
            /**
             * @author  qiao wei
             * @brief   赋值操作符。
             * @param   value 被赋值的变量。
             * @return  value变量赋值后的
             * @history name
                        date
                        brief
             */
            Card& operator=(const Card& value);
			
            virtual Card_suit_enum suit() const;
			
            virtual void set_suit(Card_suit_enum suit);
			
            virtual Card_point_enum point() const;
			
            virtual void set_point(Card_point_enum point);
			
            virtual Player* player() const;
			
            virtual void set_player(Player* player);
			
        private:
            /**
            * @author qiao wei
            * @brief  扑克牌花色。
            */
            Card_suit_enum suit_;
			
            /**
            * @author qiao wei
            * @brief  扑克牌点数。
            */
            Card_point_enum point_;
			
            /**
             * @author qiao wei
             * @brief  玩家。
             */
            Player* card_player_;
    };
	
	/**
	 * @date    2023-09-09 10:28
	 * @author  qiao wei
	 * @version 1.0
	 * @brief   比较2个Card参数是否相等。QSet's value data type must be an assignable data type, the
	 *           type must provide operator==(), and there must also be a global qHash() function
	 *           that returns a hash value for an argument of the key's type.
	 * @param   left_card Card引用类型左参数。
	 * @param   right_card Card引用类型右参数
	 * @return  当两个参数的所有变量相等，返回true，反之返回false。
	 * @throws
	 */
	bool operator==(const Card& left_card, const Card& right_card);
	
	/**
	 * @date    2023-09-09 10:29
	 * @author  qiao wei
	 * @version 1.0
	 * @brief   Function that returns a hash value for an argument of the key's type
	 * @param
	 * @return
	 * @throws
	 */
	uint qHash(const Card& card);
	
} // card

#endif //LORDCARD_CARD_H

//
// Created by qiaowei on 2024/5/9.
//


#include "../../headers/cards/card.h"


namespace card {
	
	Card::Card(QObject *parent) : QObject(parent),
	                              card_player_{new Player{"No name", parent}} {
		
	}
	
	Card::Card(const Card &value) {
		if (nullptr != &value && this != &value) {
			this->point_ = value.point_;
			this->suit_ = value.suit_;
			
			if (nullptr == card_player_) {
				card_player_ = new Player{value.card_player_->name(), value.card_player_->group()};
			} else {
				card_player_->set_name(value.card_player_->name());
				card_player_->set_gruop(value.card_player_->group());
			}
		}
	}
	
	Card::~Card() {
		if (nullptr != card_player_) {
			delete card_player_;
			card_player_ = nullptr;
		}
	}
	
	Card &Card::operator=(const Card &value) {
		if (this == &value) {
			return *this;
		}
		
		// 对所有字段进行赋值，对值类型数据直接进行赋值，如果是指针类型数据需要new新对象。
		if (nullptr != &value) {
			this->point_ = value.point_;
			this->suit_ = value.suit_;
			
			if (nullptr == card_player_) {
				card_player_ = new Player(value.card_player_->name(), value.card_player_->group());
			} else {
				card_player_->set_name(value.card_player_->name());
				card_player_->set_gruop(value.card_player_->group());
			}
		}
		
		return *this;
	}
	
	Card_suit_enum Card::suit() const {
		return suit_;
	}
	
	void Card::set_suit(Card_suit_enum suit) {
		suit_ = suit;
	}
	
	Card_point_enum Card::point() const {
		return point_;
	}
	
	void Card::set_point(Card_point_enum point) {
		point_ = point;
	}
	
	Player *Card::player() const {
		return card_player_;
	}
	
	void Card::set_player(Player *player) {
		card_player_ = player;
	}
	
	bool operator==(const Card &left_card,
	                const Card &right_card) {
		
		bool result{false};
		
		if (&left_card == &right_card) {
			result = true;
		} else {
			result = (left_card.point() == right_card.point() && left_card.suit() == right_card.suit());
		}
		
		return result;
	}
	
	uint qHash(const Card &card) {
		return (int) card.point() * 314 + (int) card.suit() * 159;
	}
}
// card