[C++] Seis funciones miembro predeterminadas en clase y clase de objeto (intermedio) (2) -- sobrecarga del operador -- sobrecarga del operador de toma de dirección y toma constante de dirección

1. Introducción

En este artículo, comenzaremos con la clase de fecha. Para una fecha, ¿cómo comparamos el tamaño? Está bien comparar el año, el mes y el día, pero ¿se puede comparar directamente?

Podemos ver que es incorrecto comparar directamente el tamaño de dos fechas para la clase de fecha del tipo personalizado, por lo que debemos otorgar funciones especiales al operador para realizar la comparación del tipo personalizado.

Algunas personas aquí pensarán, entonces puedo escribir una función relativamente pequeña, es cierto, pero esto no se recomienda. Si estamos escribiendo un proyecto con varias personas, el nombre de mi función de función comparativa es diferente del nombre que otros piensan. Cuando finalmente combinamos el código, tenemos que encontrar el nombre de función de una función específica, lo que afectará el eficiencia del desarrollo. Para evitar tal situación, C++ introduce el concepto de sobrecarga de operadores.

Echemos un vistazo a cómo lograrlo.

2. Sobrecarga de operadores

C++ introduce la sobrecarga de operadores para mejorar la legibilidad del código. La sobrecarga de operadores es una función con un nombre de función especial , y también tiene su tipo de valor de retorno, nombre de función y lista de parámetros. El tipo de valor de retorno y la lista de parámetros son similares a las funciones ordinarias. .
El nombre de la función es: la palabra clave operator seguida del símbolo del operador que debe sobrecargarse.
Prototipo de función: operador de tipo de valor de retorno operador (lista de parámetros)

Nota:
1. No se pueden crear nuevos operadores conectando otros símbolos: como operator@

2. Un operador sobrecargado debe tener un parámetro de tipo personalizado

3. El significado del operador utilizado para tipos integrados no se puede cambiar, por ejemplo: el entero integrado + no puede cambiar su significado

4. Cuando se sobrecarga como una función miembro de clase, sus parámetros formales parecen ser 1 menos que el número de operandos, porque el primer parámetro de la función miembro es el oculto.

5. El número de operandos de un operador no se puede cambiar. Un operador tiene varios operandos, por lo que hay varios parámetros al sobrecargar

6、.* :: tamaño de            ?: .                     

Tenga en cuenta que los 5 operadores anteriores no se pueden sobrecargar.

Aquí escribimos la sobrecarga de <:

Si se escribe como una función global, no se puede acceder a las variables miembro de la clase Fecha.Hay varias soluciones:

1. Cambie la variable miembro a shared , que no es segura;

2. Use amigos , que destruirán el paquete;

3. Escriba una interfaz getXXX (como para usar en Java) , lo cual es demasiado problemático, ya que es necesario escribir muchas variables miembro;

4. Coloque la función sobrecargada en la clase y se podrá acceder a las variables miembro de la clase, que es la más adecuada.

Reescribamos lo siguiente y escríbalo en la clase:

Después de la modificación:

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;
}

resultado de la operación:

Podemos ver que es correcto.

Aquí somos muy detallados Los parámetros usan referencias, lo que puede reducir la copia y el desperdicio de espacio.

3. Sobrecarga del operador de dirección y dirección constante

Estas dos funciones miembro predeterminadas generalmente no necesitan ser redefinidas y el compilador las generará de manera predeterminada.

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

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

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

Por lo general, estos dos operadores no necesitan sobrecargarse, solo use la sobrecarga de dirección predeterminada generada por el compilador. Solo en casos especiales, se requiere sobrecarga, como cuando se desea que otros obtengan el contenido especificado.