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 antes do cabeçalho da função para marcar uma funçã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.