La sobrecarga del operador de asignación C++ de una función no miembro.
Tengo una clase de variable que estoy utilizando para facilitar la escritura de scripts en mi programa. Estoy tratando de encontrar una manera fácil de hacer algo como lo siguiente:
myclass
{
protected:
int _data;
...
}
cuando sobrecargo operadores con funciones no miembro como las siguientes:
int operator+(const int, const myclass);
int operator+(const int lhs, const myclass rhs)
{
return lhs + rhs.GetData();
}
No tengo problemas hasta que intento sobrecargar un operador de asignación con una función no miembro.
int operator=(const int, const myclass);
Esto genera un error y no se compila.
error C4430: Falta el especificador de tipo: se asume “int”.
error C2801: ‘operator =’ debe ser un miembro no estático.
Solo quiero poder hacer que algo como lo siguiente funcione:
myclass A(7);
int B = 5;
int C;
C = B + A;
¿Cómo puedo lograr esto? Tengo decenas de millones de líneas de código en las que simplemente quiero reemplazar los int’s simples con myclass, pero no quiero tener que editar cada uso de esta variable.
Nota: editado para agregar mensajes de error.
Edición final:
Solución encontrada:
operator int() const { return _data; }
Al agregar la sobrecarga de operador, no necesito sobrecargar el operador de asignación como una función no miembro.
davy.ai
El problema con sobrecargar el operador de asignación como una función no miembro es que debe ser una función miembro no estática según el mensaje de error. Una solución para evitar editar cada uso de la variable es proporcionar una sobrecarga para el operador de conversión que convierte el objeto a un tipo int. Esto permitiría utilizar la variable en cualquier contexto donde se espera un int, incluyendo declaraciones de asignación.
Para implementar esta solución, tendría que agregar la siguiente función miembro a su clase:
“`c++
operator int() const {
return _data;
}
Dado que el operador de conversión convierte el objeto myclass a un int, el compilador generará automáticamente el código correcto para la operación de adición.
Tenga en cuenta que este enfoque tiene el potencial de introducir errores sutiles si no tiene cuidado. Por ejemplo, si mezcla accidentalmente el orden de los argumentos en una expresión de adición, el compilador intentará llamar al operador de conversión en el operando incorrecto, lo que podría resultar en un comportamiento inesperado.