Apostila - Programa--o C++
169 pág.

Apostila - Programa--o C++


DisciplinaAnálise Textual9.582 materiais293.987 seguidores
Pré-visualização50 páginas
na tela. 
Sobrecarregamos o operador ++() para incrementar os dados contidos em um objeto desta 
classe. Após a declaração da classe, segue a declaração do operador. Note que o operador é 
declarado como qualquer função global, a única diferença é a palavra-chave operator na frente 
do símbolo ++. O operador recebe como parâmetro um objeto da classe Ponto e retorna também um 
objeto desta classe. O operador recebe somente um parâmetro, pois no caso, este é um operador 
unário e, por definição, só pode receber um único parâmetro. O operador acessa os dados públicos 
da classe Ponto e incrementa cada um deles, retornando o próprio objeto passado como parâmetro 
com o resultado da operação. 
Em seguida, empregamos o novo operador incrementando o objeto P1 e imprimindo na tela 
o resultado gerado por este operador. 
15.2 Limitações e Características 
A sobrecarga de operadores permite uma nova implementação de maneira como um 
operador funciona. Entretanto, é necessário respeitar a definição original do operador. Por exemplo, 
não é possível mudar um operador binário (que trabalha com dois operandos) para criar um 
operador unário (que trabalha com um único operando). 
Não é permitido também estender a linguagem inventando nossos operadores representados 
com símbolos novos. Por exemplo, não se pode inventar uma operação usando o símbolo ##. Este 
símbolo não é um operador válido em C++ e você não poderá torná-lo um operador. Devemos 
limitar-nos aos operadores já existentes. 
A definição de operadores deve obedecer à precedência original do operador. Por exemplo, 
o operador de multiplicação (*) tem precedência sobre o de adição (+). Não é possível modificar 
a precedência de operadores por meio de sobrecargas. 
Nem todos os operadores podem ser sobrecarregados. Os seguintes operadores não podem 
ser sobrecarregados: o operador ponto de acesso a membros e o operador condicional ternário 
(?:). 
Os operadores unários operam sobre um único operando. Exemplos de operadores unários 
são o de incremento (++), decremento (--) e menos unário (-). Por outro lado; os operadores 
binários operam sobre dois operandos (+, -, *, /, >, +=, etc...). Por causa desta diferença, uma 
atenção especial deve ser dada ao uso de cada tipo. 
Quando definimos um operador como sendo uma função-membro de uma classe, o primeiro 
parâmetro passado para a função operadora será considerado automaticamente como sendo um 
objeto desta classe. Declarar um operador como sendo membro de uma classe, permite que este 
tenha acesso a todos os dados desta classe, tenha as permições de acesso como qualquer outra 
função membro e possa desfrutar das vantagens fornecidas pela herança de classes, apresentadas no 
próximo capítulo. 
Na declaração de operadores como funções globais, os operadores unários receberão um 
único parâmetro enquanto que os operadores binários receberão dois parâmetros. Já na declaração 
de operadores como funções-membro de uma dada classe, já que o primeiro operando é sempre um 
objeto da classe, os operadores binários não receberão parâmetros enquanto que os operadores 
binários receberão um único parâmetro. 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 111 
Uma função operadora deve ter definido um tipo de retorno, para que o resultado da 
operação com este tipo possa ser atribuidos a outras variáveis. Por exemplo, ao definir o operador 
(a+b), temos que definir que esta operação retorna algum valor do tipo da variável c, para pode 
executar a seguinte instrução: 
c = a + b; 
15.3 Sobrecarga de Operadores como Função-Membro 
No exemplo anterior, apresentamos a declaração do operador de incremento pré-fixado 
redefinido globamente. Vamos agora, redefinir este operador com uma função-membro da classe 
Ponto. 
 
#include <iostream> 
using namespace std; 
 
class Ponto 
{ 
private: 
 int X, Y; 
 
public: 
 Ponto(int aX = 0, int aY = 0) { X = aX; Y = aY; } 
 void PrintPt() const {cout << '(' << X << ','<< Y <<')';} 
 
 Ponto operator ++() //incremento prefixado 
 { 
 ++X; ++Y; 
 Ponto Temp(X,Y); 
 return Temp; 
 } 
}; 
 
int main(int argc, char* argv[]) 
{ 
 Ponto P1, P2(2,3); 
 cout << &quot;\n p1 = &quot;; 
 P1.PrintPt(); 
 cout << &quot;\n++p1 = &quot;; 
 (++P1).PrintPt(); 
 
 cout << &quot;\n++p2 = &quot;; 
 (++P2).PrintPt(); 
 P2 = ++P1; 
 cout << &quot;\n p2 = &quot;; 
 P2.PrintPt(); 
 
 Return 0; 
} 
 
Neste exemplo, efetuamos algumas modificações importantes. Os dados da classe Ponto, 
passaram a ter acesso privado, não podendo mais ser acessados por nenhuma função global. 
Sobrecarregamos o operador incremento prefixado como sendo uma função-membro da 
classe Ponto, note que agora esta função não recebe nenhum parâmetro. A definição da função é 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 112 
praticamente igual a anterior, retirando-se o parâmetro. Esta função é uma função inline da classe 
Ponto, por esta definida dentro da definição da classe. A função operadora ++() agora cria um 
objeto temporário da classe Ponto para conter o resultado da operação a ser utilizado como retorno 
da função. Veremos a seguir, formas diferentes de retornar o resultado de uma função operadora. 
Por fim, nada foi modificado no emprego do operador sobrecarregado. Note na função 
main(), que o emprego do operador não sofreu nenhuma modificação pelo fato deste ser 
declarado como uma função global ou uma função membro. 
15.4 Estudo de Casos 
Agora apresentaremos a sobrecarga de um grupo importante de operadores em C++ que 
servirão como exemplo para a sobrecarga de qualquer outro operador existente. Com este exemplo, 
discutiremos outros aspectos da sobrecarga e você perceberá também a utilizade desta ferramenta. 
O primeiro exemplo cria uma classe para armazenar as notas dos alunos. A sobrecarga de 
dois operadores foi efetuada. C++ não faz a checagem de limites de matrizes. Por causa disto, a 
manipulação de matrizes em C++ apresenta várias falhas e permite erros acidentais de sobreposição 
de dados de memória se forem usados índices que ultrapassam o limite de dimensão da matriz. Por 
isso, efetuamos a sobrecarga do operador [] para testar o limite da matriz. O outro operador, 
converterá um objeto da classe Matriz para um ponteiro float. Isto torna os objetos desta classe mais 
genéricos, podendo ser empregados facilmente para outras aplicações. 
 
//Notas : Sobrecarga do operador [] 
#include <iostream> 
#include <iomanip> 
using namespace std; 
 
const MAX = 50; 
 
class Matriz 
{ 
private: 
 float n[MAX]; 
 
public: 
 Matriz(); 
 
 float & operator [](int i); // sobrecarga [] 
 float Media(int i); 
 operator float *() const // Funcao Conversora 
 { return (float *)n; } 
}; 
 
Matriz::Matriz() 
{ 
 for(int i = 0; i<MAX; i++) 
 n[i] = 0.0; 
} 
float & Matriz::operator [](int i) 
{ 
 static float x = -1; 
 if(i >= 0 && i < MAX) 
 return n[i]; 
 else 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 113 
 { 
 cout << &quot;\nFora de Limite!&quot;; 
 return x; 
 } 
} 
float Matriz::Media(int i) 
{ 
 float m = 0.0; 
 for(int j = 0; j < i; j++) 
 m += n[j]; 
 return m/float(i); 
} 
int main(int argc, char* argv[]) 
{ 
 Matriz Notas; 
 cout << setprecision(2); 
 int i = 0; 
 do 
 { 
 cout << &quot;Digite a nota do aluno &quot; << (i + 1) << &quot; : &quot;; 
 cin >> Notas[i]; 
 }while (Notas[i++] >= 0); 
 i--; 
 float * Temp = Notas; 
 cout << &quot;\nNota do Segundo Aluno &quot; << *(Temp + 1); 
 cout << &quot;\n\nMedia das notas : &quot; << Notas.Media(i); 
 return 0; 
} 
O programa cria uma matriz fixa para armazenar as notas dos alunos, imprimindo a média 
das notas no final. A novidade é a função operator[] que