[C++] Six fonctions membres par défaut dans la classe et la classe objet (moyenne) (2) -- surcharge d'opérateur -- prendre l'adresse et const prendre l'adresse surcharger l'opérateur

1. Introduction

Dans cet article, nous commencerons par la classe de date. Pour un rendez-vous, comment compare-t-on la taille ? Il est acceptable de comparer tour à tour l'année, le mois et le jour, mais peut-on le comparer directement ?

Nous pouvons voir qu'il est faux de comparer directement la taille de deux dates pour la classe de date du type personnalisé, nous devons donc donner des fonctions spéciales à l'opérateur pour réaliser la comparaison du type personnalisé.

Certaines personnes ici penseront, alors je peux écrire une fonction relativement petite, c'est vrai, mais ce n'est pas recommandé. Si nous écrivons un projet avec plusieurs personnes, le nom de ma fonction de comparaison est différent du nom auquel les autres pensent. Lorsque nous combinons enfin le code, nous devons trouver le nom de fonction d'une fonction spécifique, qui affectera le efficacité du développement. Afin d'éviter une telle situation, C++ introduit le concept de surcharge d'opérateur.

Voyons comment y parvenir.

2. Surcharge de l'opérateur

C++ introduit la surcharge d'opérateur pour améliorer la lisibilité du code. La surcharge d'opérateur est une fonction avec un nom de fonction spécial et a également son type de valeur de retour, son nom de fonction et sa liste de paramètres. Son type de valeur de retour et sa liste de paramètres sont similaires aux fonctions ordinaires .
Le nom de la fonction est : le mot clé operator suivi du symbole de l'opérateur qui doit être surchargé.
Prototype de fonction : opérateur d'opérateur de type valeur de retour (liste de paramètres)

Remarque :
1. De nouveaux opérateurs ne peuvent pas être créés en connectant d'autres symboles : tels que opérateur@

2. Un opérateur surchargé doit avoir un paramètre de type personnalisé

3. La signification de l'opérateur utilisé pour les types intégrés ne peut pas être modifiée, par exemple : l'entier intégré + ne peut pas modifier sa signification

4. Lorsqu'il est surchargé en tant que fonction membre de classe, ses paramètres formels semblent être inférieurs de 1 au nombre d'opérandes, car le premier paramètre de la fonction membre est le caché this

5. Le nombre d'opérandes d'un opérateur ne peut pas être modifié. Un opérateur a plusieurs opérandes, il y a donc plusieurs paramètres lors d'une surcharge

6、.* :: taillede            ?: .                     

Notez que les 5 opérateurs ci-dessus ne peuvent pas être surchargés.

Ici, nous écrivons la surcharge de < :

Si elle est écrite comme une fonction globale, les variables membres de la classe Date ne sont pas accessibles. Il existe plusieurs solutions :

1. Remplacez la variable membre par shared , ce qui n'est pas sûr ;

2. Utilisez des amis , ce qui détruira le colis ;

3. Écrivez une interface getXXX (comme celle utilisée en Java) , ce qui est trop gênant, car de nombreuses variables membres doivent être écrites ;

4. Placez la fonction surchargée dans la classe et les variables membres de la classe sont accessibles, ce qui est le plus approprié.

Réécrivons ce qui suit et écrivons-le dans la classe :

Après modification:

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//拷贝构造
	Date(const Date& d)// 拷贝构造对d不做改变，因此加上const防止违法使用
	{				   //并且对于引用来说，这也是权限的缩小，因此加const会更优
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	~Date()
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}

	// d1 < d2 等同于 d1.operator<(d2)，这里比较的顺序是不能交换的
	bool operator<(const Date& d)// 这里省略了第一个参数this
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year = d._year && _month < d._month && _day < d._day)
		{
			return true;
		}
		else
		{
			return false;
		}

	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2003, 1, 1);
	Date d2(2023, 8, 2);
	cout << (d1 < d2) << endl;
	cout << (d1.operator<(d2)) << endl;

    return 0;
}

résultat de l'opération :

On voit que c'est correct.

Ici, nous sommes très détaillés, les paramètres utilisent des références, ce qui peut réduire les copies et le gaspillage d'espace.

3. Surcharge de l'opérateur d'adresse et d'adresse const

Ces deux fonctions membres par défaut n'ont généralement pas besoin d'être redéfinies et le compilateur les génère par défaut.

class Date
{
public :
    Date* operator&()
    {
    return this ;
    }

    const Date* operator&()const
    {
    return this ;
    }

private :
    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
};

Ces deux opérateurs n'ont généralement pas besoin d'être surchargés, il suffit d'utiliser la surcharge de prise d'adresse par défaut générée par le compilateur. Seulement dans des cas particuliers, une surcharge est nécessaire, comme vouloir que d' autres obtiennent le contenu spécifié !