Apostila UFSC - Linguagem C
170 pág.

Apostila UFSC - Linguagem C


DisciplinaLinguagem de Programação C277 materiais910 seguidores
Pré-visualização50 páginas
que faça o controle de cadastro de usuários e controle de alocação 
para uma locadora de fitas de vídeo. Utilize uma classe para os clientes e outra para as fitas, e 
emprege o método da lista ligada para gerenciar um vetor dinâmico. O usuário deve poder 
incluir/retirar um cliente ou uma fita, fazer uma pesquisa, pedir a lista de clientes e a lista de fitas ou 
alterar algum parâmetro destas. 
14.4 Escreva um programa para controlar o acesso das vagas de um estacionamento. 
Armazene dados importantes do carro como chapa do carro, a hora de entrada, a hora de saída. 
Controle a lotação do estacionamento e verifique se existem vagas disponíveis. O programa deve 
Curso de Linguagem Computacional C/C++
 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 107
gerar automaticamente o preço do estacionamento, quando o usuário retirar o carro. Não esqueça 
que alguns clientes podem ficar mais tempo do que o tempo notificado. 
14.5 Modele o problema do jogo do xadrex apresentado no início do capítulo. Mas não 
jogue contra o computador mas contra um outro usuário usando o mesmo micro. 
Curso de Linguagem Computacional C/C++
 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 108
15 Sobrecarga de Operadores 
O sentido do polimorfismo é o de um único nome para definir várias formas distintas. Em 
C++, chamamos de polimorfismo a criação de uma família de funções que compartilham do mesmo 
nome, mas cada uma tem código independente. O resultado da ação de cada uma das funções da 
família é o mesmo. A maneira de atingir esse resultado é distinta. 
Como exemplo, suponhamos que desejamos calcular o salário líquido de todos os 
funcionários de uma empresa. Nessa empresa, há horistas, mensalistas, os que ganham por 
comissão, etc. Criamos um conjunto de funções em que cada uma tem um método diferente de 
calcular o salário. Quando a função é chamada, C++ saberá identificar qual é a função com o código 
adequado ao contexto. 
A sobrecarga é um tipo particular de polimorfismo. Como exemplo, tomemos operador 
aritmético (+). Em C++, usamos esse operador para somar números inteiros ou para somar números 
reais: 
5 + 4 
3.7 + 12.5 
O computador executa operações completamente diferentes para somar números inteiros e 
números reais. A utilização de um mesmo símbolo para a execução de operações distintas é 
chamada sobrecarga. O polimorfismo e a sobrecarga são habilidades únicas em linguagens 
orientadas a objetos. 
Os operadores em C++ são definidos como funções normais onde o nome da função é o 
símbolo do operador e os parâmetros da função são os operandos do operador. Por exemplo, o 
operador de soma para números inteiros possui uma declaração do tipo: 
int operator +(int a, int b); 
Ou seja, a operação (a+b), é vista por C++ como uma chamada à função acima declarada. 
Quando escrevermos em nosso código esta operação, C++ utilizará a definição desta função para 
efetuar a operação. Note que a única diferença na declaração ou definição de um operador é que o 
nome de um operador é definido pela palavra chave operator seguida de espaço mais o símbolo 
que representa o operador, neste caso (+). 
Assim, podemos tratar qualquer operador como sendo uma função normal mas que possui 
um nome especial e uma forma especial de chamada. Perceba, que quando escrevemos no código 
(a+b), C++ interpreta esta instrução como uma chamada a função operator + e passa para esta os 
parâmetros a e b. 
Se os operadores são tratados por C++ como uma função qualquer, qual a razão da sua 
existência? Suponha, que tenhamos definido a seguinte função que executa a operação (a + b) : 
int soma(int a, int b); 
Qual das duas formas abaixo é mais clara e intuitiva para se escrever a soma de dois 
números: 
int c = soma( a, b); 
int c = a + b; 
É claro que será segunda forma. Por isso, podemos tornar o nosso código fonte muito mais 
organizado e claro empregando-se os operadores ao invés de funções normais. 
Assim como qualquer outra função em C++, os operadores podem ser sobrecarregados para 
outras aplicações, i.e., podemos redefinir os operadores para serem empregados em outros tipos de 
Curso de Linguagem Computacional C/C++
 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 109
dados criados pelo programador. Suponha que tenhamos criado uma classe para representar os 
números complexos chamada complexo. Então, com a sobrecarga do operador (+) poderemos 
redefinir a seguinte função para dois elementos da nossa classe: 
complexo A, B; 
A = A + B; 
Note, que esta definição é bem intuitiva e clara. Esta característica é muito importante para o 
programador, permitindo que este possa definir como os operadores existentes em C++ atuarão com 
relação aos tipos de dados definidos pelo programador. 
Somente os operadores já existentes em C++ podem ser sobrecarregados (redefinidos) para 
operar sobre novos tipos de dados definidos pelo programador. Por exemplo, não podemos definir o 
símbolo (#) como um operador, pois este símbolo não é declarado por C++ como sendo um 
operador. 
Sobrecarregar um operador significa redefinir o seu símbolo, de maneira que ele se aplique 
também a tipos de dados definidos pelo usuário como classes e estruturas. Sobrecarregar uma 
função significa utilizar um mesmo nome para tarefas parecidas, mas de códigos de programa 
diferentes. Várias funções com o mesmo nome podem apresentar diferentes implementações 
(trechos de programa). No instante em que você encontrar uma limitação pelo modo como os 
operadores C++ trabalham, pode mudá-los conforme as suas necessidades, por meio de sobrecargas. 
15.1 A Sobrecarga como uma Função Global 
A implementação de sobrecargas de operadores é definida por meio de funções chamadas 
operadoras. Estas funções podem ser criadas como membros de classes ou como funções globais, 
acessíveis a todo o programa. 
A seguir vamos apresentar a sobrecarga do operador ++() incremento prefixado para a 
classe Ponto, criada para representar um ponto localizado no espaço bidimensional, por isso contém 
as coordenadas x e y do ponto. 
//Ponto2 - Mostra a sobrecarga de operadores 
#include <iostream> 
using namespace std; 
class Ponto 
{ 
public: 
int X, Y; 
Ponto(int aX = 0, int aY = 0) { X = aX; Y = aY; } 
void PrintPt() const {cout << '(' << X << ','<< Y <<')';} 
}; 
Ponto operator ++(Ponto ObjPonto) //incremento prefixado 
{ 
++ObjPonto.X; ++ObjPonto.Y; 
return ObjPonto; 
} 
int main(int argc, char* argv[]) 
{ 
Ponto P1(1,2); 
cout << &quot;\n p1 = &quot;; 
P1.PrintPt(); 
Curso de Linguagem Computacional C/C++
 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 110
 
cout << &quot;\n++p1 = &quot;; 
(++P1).PrintPt(); 
return 0; 
} 
A classe Ponto é uma classe normal, possui dois atributos com acesso público, uma função 
construtora para incializar os atributos e uma função para imprimir os dados 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