Saltar al contenido

Sobrecarga de operadores de C ++ con ejemplos

¿Qué es la sobrecarga del operador?

Utilizando sobrecarga del operador en C ++, puede especificar más de un significado para un operador en un solo ámbito. El propósito de la sobrecarga de operador es proporcionar un significado de operador especial para un tipo de datos definido por el usuario.

Con la ayuda de la sobrecarga de operadores, puede redefinir la mayoría de los operadores de C ++. También puede utilizar la sobrecarga del operador para realizar varias operaciones con un solo operador.

En este tutorial de C ++, aprenderá:

Proporción

Para sobrecargar un operador de C ++, debe definir una función especial dentro de la Clase de la siguiente manera:


class class_name
{
    ... .. ...
    public
       return_type operator symbol (argument(s))
       {
           ... .. ...
       } 
    ... .. ...
};

Aquí hay una explicación de la sintaxis anterior:

Ejemplo 1:


#include <iostream>
using namespace std;
class TestClass {
private:
	int count;
public:
	TestClass() : count(5) {}
	void operator --() {
		count = count - 3;
	}
	void Display() { 

		cout << "Count: " << count; }
};

int main() {
	TestClass tc;
	--tc;
	tc.Display();
	return 0;
}

Producción:

Aquí hay una imagen del código:

Explicación del Código:

  1. Incluye el archivo de encabezado iostream en nuestro código para usar sus funciones.
  2. Incluya el nombre de espacio estándar en nuestro programa para usar sus clases sin llamarlo.
  3. Cree una clase llamada TestClass.
  4. Utilice el moderador de acceso privado, que marca a un miembro de la clase como accesible de forma privada.
  5. Cree un recuento de variables enteras. Esta variable será de acceso privado.
  6. Utilice el modificador de acceso público, que marca a un miembro de la clase como de acceso privado.
  7. Utilice un constructor de clases para iniciar la variable de contador a 5.
  8. Operador significa sobrecarga.
  9. El operador reducirá el valor de la variable x en 1.
  10. Fin de la porción de sobrecarga del operador. Se le ha dado un nuevo nombre al operador.
  11. Defina una función llamada Display ().
  12. Imprime el valor de la cuenta variable junto con otro texto en la consola cuando se llama a la función Display (). } Marca el final del cuerpo de la función de visualización ().
  13. El final del cuerpo.
  14. Llame a la función principal (). La lógica del programa debe agregarse a esta función.
  15. Cree un ejemplo de la clase TestClass y asígnele el nombre tc.
  16. Esto aplicará la función de operador nulo (-).
  17. Utilice la posición de la clase TestClass para llamar a la función Display ().
  18. La función debe devolver un valor una vez completada con éxito.
  19. El final del cuerpo de la función principal ().

Diferentes enfoques para la sobrecarga del operador en C ++

Puede sobrecargar operadores implementando cualquiera de los siguientes tipos de funciones:

  1. Función miembro
  2. Función no miembro
  3. Función amigos

Puede realizar una función de sobrecarga para la función de operador si desea acceder a miembros de clase privados y protegidos.

¿Se pueden sobrecargar todos los operadores de C ++?

Hay operadores de C ++ que no se pueden sobrecargar.

Éstas incluyen:

Cosas para recordar:

  1. Con la sobrecarga de operadores, solo puede redefinir la forma en que un operador trabaja para los tipos definidos por el usuario (objetos, estructuras). No puede usarlo para tipos integrados (float, char, int, etc.).
  2. Los operadores = y & C ++ están sobrecargados de forma predeterminada. Por ejemplo, puede copiar objetos de la misma clase directamente usando el operador =.
  3. La prioridad del operador asociado y la prioridad del operador no cambian. Sin embargo, puede cambiar el orden de la evaluación utilizando un corchete.
  4. Hay cuatro operadores que no puede sobrecargar en C ++. Incluyen el operador de resolución de alcance (: :), el operador de selección de miembros (.), La selección de miembros mediante un puntero a un operador funcional (. *) Y el operador ternario (? :).

Reglas de sobrecarga del operador:

Estas son las reglas para la sobrecarga del operador:

Cómo sobrecargar a un operador:

Ejemplo 1:


#include <iostream>   
using namespace std;
class OperatorOverload {
private:
	int x;

public:
	OperatorOverload() : x(10) {}
	void operator ++() {
		x = x + 2;
	}
	void Print() {
		cout << "The Count is: " << x;
		}
};
int main() {
	OperatorOverload ov;
	++ov;   
	ov.Print();
	return 0;
}

Producción:

Aquí hay una imagen del código:

Explicación del Código:

  1. Incluye el archivo de encabezado iostream en nuestro código para usar sus funciones.
  2. Incluya el nombre de espacio estándar en nuestro programa para usar sus clases sin llamarlo.
  3. Cree una clase denominada OperatorOverload.
  4. Utilice el moderador de acceso privado, que marca a un miembro de la clase como accesible de forma privada.
  5. Cree una variable entera x. Esta variable será de acceso privado.
  6. Utilice el modificador de acceso público, que marca a un miembro de la clase como de acceso privado.
  7. Utilice un constructor de clases para iniciar una variable x en 10.
  8. Operador que significa sobrecarga ++.
  9. El operador aumentará el valor de la variable xa en 2.
  10. Fin de la porción de sobrecarga del operador. Al operador se le ha dado un nuevo nombre.
  11. Llamar a la función Imprimir ().
  12. Imprime un valor de variable x junto a otro texto en la consola cuando se llama a la función Imprimir ().
  13. Fin del cuerpo de la función Print ().
  14. El final del cuerpo.
  15. Llame a la función principal (). La lógica del programa debe agregarse a esta función.
  16. Cree un ejemplo de la clase OperatorOverload denominada ov.
  17. Esto hará que la función del operador sea nula ++ ().
  18. Utilice la posición de la clase OperatorOverload para llamar a la función Print ().
  19. La función debe devolver un valor una vez completada con éxito.
  20. El final del cuerpo de la función principal ().

Ejemplo 2:


#include<iostream> 
using namespace std;

class TestClass {
private:
	int real, over;
public:
	TestClass(int rl = 0, int ov = 0) {
		real = rl;
		over = ov;
	}

	TestClass operator + (TestClass const &obj) {
		TestClass result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() {
		cout << real << " + i" << over << endl;
	}
};
int main()
{
	TestClass c1(9, 5), c2(4, 3);
	TestClass c3 = c1 + c2;
	c3.print();
}

Producción:

Aquí hay una imagen del código:

Explicación del Código:

  1. Incluya el archivo de encabezado istrum en nuestro programa para usar sus funciones.
  2. Incluya el nombre de espacio estándar en nuestro programa para poder usar sus clases sin llamarlo.
  3. Cree una clase llamada TestClass. La marca {es el comienzo del cuerpo.
  4. Utilice el modificador de acceso privado para marcar las variables como privadas, lo que significa que solo se puede acceder a ellas dentro de la Clase.
  5. Defina dos variables enteras, verdaderas y superiores.
  6. Utilice el modificador de acceso público para marcar el constructor como público, lo que significa que será accesible incluso fuera de la Clase.
  7. Cree el generador de clases e inicie las variables.
  8. Comience con un valor realizable variable.
  9. Empiece de nuevo con el valor de la variable.
  10. El fin del carrocero.
  11. Anula el significado del operador +.
  12. Cree el resultado del tipo de datos de tipo TestClass.
  13. Utilice el operador + con números complejos. Esta línea agregará un número real a otro número real.
  14. Utilice el operador + con números complejos. Esta línea agregará la parte imaginaria de un número a la parte imaginaria de otro número.
  15. El programa devolverá el valor de la variable resultado en una ejecución exitosa.
  16. Fin de la definición de nuevo significado + operador, es decir, sobrecarga.
  17. Llame al método de impresión ().
  18. Imprima el nuevo número complejo después de colocarlo en la consola.
  19. El final del cuerpo de la función de impresión ().
  20. TestClass Class final del cuerpo.
  21. Llamando a la función principal ().
  22. Superando los valores de las partes reales y complejas a sumar. La primera parte de c1 se agregará a la primera parte de c2, es decir, 9 + 4. La segunda parte de c1 se agregará a la segunda parte de c, es decir, 5 + 3.
  23. Opere usando el operador overload + y almacene el resultado en la variable c3.
  24. Imprime un valor variable de c3 en la consola.
  25. El final del cuerpo de la función principal ().

Resumen: