Sobrecarga de operador em templates. Escreva
um template simples para a função predicado isEqual-
To que compare seus dois argumentos do mesmo tipo
com o operador de igualdade (==), e retorne true se
eles forem iguais e false se eles forem diferentes. Use
esse template de função em um programa que chame
isEqualTo apenas com uma série de tipos fundamentais.
Agora, escreva uma versão separada do programa
que chama isEqualTo com um tipo de classe definido
pelo usuário, mas não sobrecarrega o operador de igualdade.
O que acontece quando você tenta executar esse
programa? Agora, sobrecarregue o operador de igualdade
(com a função operador) operator==. O que acontece
quando você tenta executar esse programa?
Passo 1
Vamos criar uma função de modelo de predicado que compara dois operandos com o operador de igualdade. Em seguida, tentaremos passar tipos de classe definidos pelo usuário sem e com um operador de igualdade sobrecarregado.
Tipos fundamentais
Use a instrução de modelo
Utilize o tipo T nos parâmetros da seguinte forma:
template
bool isEqualTo(T op1, T op2)
{
return op1 == op2;
}
Demonstração
int main()
{
int aInt = 1, bInt = 1;
float aFloat = 1.0f, bFloat = 1.0f;
if (isEqualTo(aInt, bInt))
cout
if (isEqualTo(aFloat, bFloat))
cout
}
Passo 2
Tipos de classe definidos pelo usuário
Vamos criar uma classe simples com um membro de dados, um construtor e funções getter/setter.
#ifndef H_MYCLASS_H
#define H_MYCLASS_H
class MyClass {
public:
explicit MyClass(int i);
int getI() const;
void setI(int i);
private:
int i;
};
#endif
Class implementation:
#include "MyClass.h"
MyClass::MyClass(int i) : i(i) {}
int MyClass::getI() const {
return i;
}
void MyClass::setI(int i) {
MyClass::i = i;
}
Passo 3
Demonstração
Se tentarmos compilar o seguinte código:
#include
#include "MyClass.h"
using namespace std;
template
bool isEqualTo(T op1, T op2)
{
return op1 == op2;
}
int main()
{
MyClass object1(13), object2(13);
if (isEqualTo(object1, object2))
cout
}
Receberíamos um erro do compilador informando que não há correspondência para o operador==. Isso ocorre porque as funções de modelo são instanciadas em tempo de compilação.
Tipos de classe definidos pelo usuário com operador de igualdade de sobrecarga
Declaração de classe atualizada:
#ifndef H_MYCLASS_H
#define H_MYCLASS_H
class MyClass {
public:
explicit MyClass(int i);
int getI() const;
void setI(int i);
bool operator==(const MyClass&) const;
private:
int i;
};
#endif
Implementação de classe atualizada:
#include "MyClass.h"
MyClass::MyClass(int i) : i(i) {}
int MyClass::getI() const {
return i;
}
void MyClass::setI(int i) {
MyClass::i = i;
}
bool MyClass::operator==(const MyClass &right) const {
return right.i == i;
}
Demonstração
Agora, se o aplicativo fosse executado, tudo funcionaria sem problemas:
#include
#include "MyClass.h"
using namespace std;
template
bool isEqualTo(T op1, T op2)
{
return op1 == op2;
}
int main()
{
MyClass object1(13), object2(13);
if (isEqualTo(object1, object2))
cout
}
Resposta
Ver o desenvolvimento.