Realicé el siguiente algoritmo para que el operador "==", al aplicar
entre dos cadenas de caracteres, devuelva el valor de verdad de la
igualdad exacta de ambas cadenas de caracteres:

1. #include <cstdlib>
2. #include <iostream>
3.
4. using namespace std;
5.
6. bool operator == (char *cadena1, char *cadena2)
7. {
8. bool temp = true;
9.
10. if (strlen(cadena1) != strlen(cadena2))
11. temp = false;
12. else
13. {
14. for (int i = 0; i <= strlen(cadena1); ++i)
15. {
16. if (cadena1[i] != cadena2[i])
17. temp = false;
18. }
19. }
20.
21. return temp;
22. }

Y surge el siguiente error, para la línea 7:

`bool operator==(char*, char*)' must have an argument of class or
enumerated type

¿Consejos? Me sería útil recibir algo de ayuda. Gracias por adelantado.

El error del compilador te lo dice muy claro. Generalizando: las funciones
'operator' necesitan que al menos un argumento sea una clase o un enum. No
se pueden redefinir para los tipos básicos. La razón es evitar malas ideas.

Por ejemplo, podrías tener la idea de hacer
bool operator==(double d1, double d2) {
// Algoritmo para sólo comprobar hasta dos decimales e ignorar el resto
}
Si esta operación la incluyeras en tu programa, tú sabrias lo que haces y
probablemente el programa haría lo que pretendes (diría que si comparando
3,141183 y 3,147895), pero también podrías estar cambiando cualquier
comparación de doubles de cualquier librería que utilizaras. Es más, cuando
repasarás el programa después de algún tiempo probablemente no recordarías
que el igual de doubles no es el estandar y tendrías poblemas para el
mantenimiento del programa a largo plazo.

De todas maneras, si se pudiera hacer, yo lo haría así:

bool operator==(const char *cadena1, const char *cadena2) {
while (*cadena1 && *cadena2)
if (*(cadena1++ )!= *(cadena2++))
return false;
return *cadena1 == *cadena2;
}

Aunque lo mas simple es utilizar "!strcmp(cadena1,cadena2)"

El error del compilador te lo dice muy claro. Generalizando: las funciones
'operator' necesitan que al menos un argumento sea una clase o un enum. No
se pueden redefinir para los tipos básicos. La razón es evitar malas ideas.

Por ejemplo, podrías tener la idea de hacer
bool operator==(double d1, double d2) {
// Algoritmo para sólo comprobar hasta dos decimales e ignorar el resto
}
Si esta operación la incluyeras en tu programa, tú sabrias lo que haces y
probablemente el programa haría lo que pretendes (diría que si comparando
3,141183 y 3,147895), pero también podrías estar cambiando cualquier
comparación de doubles de cualquier librería que utilizaras. Es más, cuando
repasarás el programa después de algún tiempo probablemente no recordarías
que el igual de doubles no es el estandar y tendrías poblemas para el
mantenimiento del programa a largo plazo.

De todas maneras, si se pudiera hacer, yo lo haría así:

bool operator==(const char *cadena1, const char *cadena2) {
while (*cadena1 && *cadena2)
if (*(cadena1++ )!= *(cadena2++))
return false;
return *cadena1 == *cadena2;
}

Aunque lo mas simple es utilizar "!strcmp(cadena1,cadena2)"

El error del compilador te lo dice muy claro. Generalizando: las funciones
'operator' necesitan que al menos un argumento sea una clase o un enum. No
se pueden redefinir para los tipos básicos. La razón es evitar malas ideas.

Por ejemplo, podrías tener la idea de hacer
bool operator==(double d1, double d2) {
// Algoritmo para sólo comprobar hasta dos decimales e ignorar el resto
}
Si esta operación la incluyeras en tu programa, tú sabrias lo que haces y
probablemente el programa haría lo que pretendes (diría que si comparando
3,141183 y 3,147895), pero también podrías estar cambiando cualquier
comparación de doubles de cualquier librería que utilizaras. Es más, cuando
repasarás el programa después de algún tiempo probablemente no recordarías
que el igual de doubles no es el estandar y tendrías poblemas para el
mantenimiento del programa a largo plazo.

De todas maneras, si se pudiera hacer, yo lo haría así:

bool operator==(const char *cadena1, const char *cadena2) {
while (*cadena1 && *cadena2)
if (*(cadena1++ )!= *(cadena2++))
return false;
return *cadena1 == *cadena2;
}

Aunque lo mas simple es utilizar "!strcmp(cadena1,cadena2)"

El error del compilador te lo dice muy claro. Generalizando: las funciones
'operator' necesitan que al menos un argumento sea una clase o un enum. No
se pueden redefinir para los tipos básicos. La razón es evitar malas ideas.

Por ejemplo, podrías tener la idea de hacer
bool operator==(double d1, double d2) {
// Algoritmo para sólo comprobar hasta dos decimales e ignorar el resto
}
Si esta operación la incluyeras en tu programa, tú sabrias lo que haces y
probablemente el programa haría lo que pretendes (diría que si comparando
3,141183 y 3,147895), pero también podrías estar cambiando cualquier
comparación de doubles de cualquier librería que utilizaras. Es más, cuando
repasarás el programa después de algún tiempo probablemente no recordarías
que el igual de doubles no es el estandar y tendrías poblemas para el
mantenimiento del programa a largo plazo.

De todas maneras, si se pudiera hacer, yo lo haría así:

bool operator==(const char *cadena1, const char *cadena2) {
while (*cadena1 && *cadena2)
if (*(cadena1++ )!= *(cadena2++))
return false;
return *cadena1 == *cadena2;
}

Aunque lo mas simple es utilizar "!strcmp(cadena1,cadena2)"

El error del compilador te lo dice muy claro. Generalizando: las funciones
'operator' necesitan que al menos un argumento sea una clase o un enum. No
se pueden redefinir para los tipos básicos. La razón es evitar malas ideas.

Por ejemplo, podrías tener la idea de hacer
bool operator==(double d1, double d2) {
// Algoritmo para sólo comprobar hasta dos decimales e ignorar el resto
}
Si esta operación la incluyeras en tu programa, tú sabrias lo que haces y
probablemente el programa haría lo que pretendes (diría que si comparando
3,141183 y 3,147895), pero también podrías estar cambiando cualquier
comparación de doubles de cualquier librería que utilizaras. Es más, cuando
repasarás el programa después de algún tiempo probablemente no recordarías
que el igual de doubles no es el estandar y tendrías poblemas para el
mantenimiento del programa a largo plazo.

De todas maneras, si se pudiera hacer, yo lo haría así:

bool operator==(const char *cadena1, const char *cadena2) {
while (*cadena1 && *cadena2)
if (*(cadena1++ )!= *(cadena2++))
return false;
return *cadena1 == *cadena2;
}

Aunque lo mas simple es utilizar "!strcmp(cadena1,cadena2)"

El error del compilador te lo dice muy claro. Generalizando: las funciones
'operator' necesitan que al menos un argumento sea una clase o un enum. No
se pueden redefinir para los tipos básicos. La razón es evitar malas ideas.

Por ejemplo, podrías tener la idea de hacer
bool operator==(double d1, double d2) {
// Algoritmo para sólo comprobar hasta dos decimales e ignorar el resto
}
Si esta operación la incluyeras en tu programa, tú sabrias lo que haces y
probablemente el programa haría lo que pretendes (diría que si comparando
3,141183 y 3,147895), pero también podrías estar cambiando cualquier
comparación de doubles de cualquier librería que utilizaras. Es más, cuando
repasarás el programa después de algún tiempo probablemente no recordarías
que el igual de doubles no es el estandar y tendrías poblemas para el
mantenimiento del programa a largo plazo.

De todas maneras, si se pudiera hacer, yo lo haría así:

bool operator==(const char *cadena1, const char *cadena2) {
while (*cadena1 && *cadena2)
if (*(cadena1++ )!= *(cadena2++))
return false;
return *cadena1 == *cadena2;
}

Aunque lo mas simple es utilizar "!strcmp(cadena1,cadena2)"

Comprendo lo que me dices. Mi interés era sobrecargar el operador
y grabar en una librería (o cabecera, como gustes llamar), para
facilitar a una persona el trabajo con C++. Como verificar la
veracidad "cadena1 == cadena2" no te dice que cada caracter de uno es
idéntico a otro (en los lugares correspondientes, como ejemplo "hola"
== "hola"), quise sobrecargar dicho operador a una función que me
parecía lógica.

Aunque me falta mucho para ser experto en C++, tengo un buen
dominio de ciertas propiedades del lenguaje (llevo como cuatro meses
practicando el lenguaje, y he aprendido considerablemente para lo que
esperaba). Los trabajos que realizamos (estudiante de nivel secundario
en un colegio soy), los demás hacen mediante Quick Basic. Como me
dieron la certeza de que trabajaría con C++ (pues me resulta más
fácil), y se debe trabajar en parejas, la otra persona debe acomodarse
a la sintaxis, pero no está preparada para comprender todos los
pormenores del lenguaje, y quiero simplificar la tarea.

Comprendo lo que me dices. Mi interés era sobrecargar el operador
y grabar en una librería (o cabecera, como gustes llamar), para
facilitar a una persona el trabajo con C++. Como verificar la
veracidad "cadena1 == cadena2" no te dice que cada caracter de uno es
idéntico a otro (en los lugares correspondientes, como ejemplo "hola"
== "hola"), quise sobrecargar dicho operador a una función que me
parecía lógica.

Aunque me falta mucho para ser experto en C++, tengo un buen
dominio de ciertas propiedades del lenguaje (llevo como cuatro meses
practicando el lenguaje, y he aprendido considerablemente para lo que
esperaba). Los trabajos que realizamos (estudiante de nivel secundario
en un colegio soy), los demás hacen mediante Quick Basic. Como me
dieron la certeza de que trabajaría con C++ (pues me resulta más
fácil), y se debe trabajar en parejas, la otra persona debe acomodarse
a la sintaxis, pero no está preparada para comprender todos los
pormenores del lenguaje, y quiero simplificar la tarea.

Comprendo lo que me dices. Mi interés era sobrecargar el operador
y grabar en una librería (o cabecera, como gustes llamar), para
facilitar a una persona el trabajo con C++. Como verificar la
veracidad "cadena1 == cadena2" no te dice que cada caracter de uno es
idéntico a otro (en los lugares correspondientes, como ejemplo "hola"
== "hola"), quise sobrecargar dicho operador a una función que me
parecía lógica.

Aunque me falta mucho para ser experto en C++, tengo un buen
dominio de ciertas propiedades del lenguaje (llevo como cuatro meses
practicando el lenguaje, y he aprendido considerablemente para lo que
esperaba). Los trabajos que realizamos (estudiante de nivel secundario
en un colegio soy), los demás hacen mediante Quick Basic. Como me
dieron la certeza de que trabajaría con C++ (pues me resulta más
fácil), y se debe trabajar en parejas, la otra persona debe acomodarse
a la sintaxis, pero no está preparada para comprender todos los
pormenores del lenguaje, y quiero simplificar la tarea.