Baixe Programação Linguagem C++ e outras Notas de estudo em PDF para Introdução à Programação de Computadores, somente na Docsity!
"C++ COMO UMA LINGUAGEM DE PROGRAMAÇÃO ORIENTADA A
- TUTORIAL:
- CLASSES E OBJETOS
- 1.1. ESPECIFICANDO UMA CLASSE............................................................................
- 1.2. STRUCT EM C++.......................................................................................................
- 1.2.1. ATRIBUTOS OU DADOS MEMBRO.
- 1.2.2. MÉTODOS OU FUNÇÕES MEMBRO.
- 1.2.3. FUNÇÕES MEMBRO QUE RETORNAM VALORES.
- CHAMAMANDO FUNÇÕES MEMBRO. 1.2.4. FUNÇÕES DECLARADAS EXTERNAS A CLASSE , FUNÇÕES MEMBRO
- 1.2.5. ALGO PARECIDO EM UMA LINGUAGEM PROCEDURAL......................
- 1.2.6. CONSTRUTORES.............................................................................................
- 1.2.7. CONSTRUTORES E AGREGAÇÃO
- 1.2.8. DESTRUTORES................................................................................................
- 1.3. ENCAPSULAMENTO COM "CLASS"
- 1.3.1. ATRIBUTOS PRIVATE, FUNÇÕES MEMBRO PUBLIC...........................
- 1.3.2. UM DADO MEMBRO É PUBLIC
- 1.3.3. COMPILANDO UM PROGRAMA COM VÁRIOS ARQUIVOS...................
- 1.4. TIPO ABSTRATO DE DADOS
- 1.4.1. TAD FRAÇÃO...................................................................................................
- 1.5. CONSIDERAÇÕES C++:.........................................................................................
- 1.5.1. CONST
- 1.5.2. FUNÇÕES INLINE............................................................................................
- 1.5.3. ALOCAÇÃO DINÂMICA COM NEW E DELETE.........................................
- 1.5.4. REFERÊNCIA &
- 1.6. RECAPITULANDO..................................................................................................
- 1.6.1. ARGUMENTOS DE LINHA DE COMANDO.
- HERANÇA.......................................................................................................................
- 2.1. HIERARQUIAS DE TIPOS......................................................................................
- 2.1.1. UMA HIERARQUIA SIMPLES.
- 2.1.2. PROTECTED
- 2.1.3. REDEFINIÇÃO DE FUNÇÕES MEMBRO HERDADAS
- 2.1.4. UMA HIERARQUIA DE LISTAS LIGADAS
- 2.2. HIERARQUIAS DE IMPLEMENTAÇÃO
- 2.2.1. FILA A PARTIR DE UMA LISTA
- POLIMORFISMO, FUNÇÕES VIRTUAIS
- 3.1. O QUE SIGNIFICA POLIMORFISMO
- 3.1.1. SOBRECARGA DE MÉTODOS.....................................................................
- HERDEIRA................................................................................................................ 3.1.2. REDEFINIÇÃO DE UMA FUNÇÃO MEMBRO PARA UMA CLASSE
- 3.1.3. "COPY CONSTRUCTOR"..............................................................................
- 3.1.4. SOBRECARGA DE FUNÇÃO EM C++.
- 3.1.5. "DEFAULT ARGUMENTS", VALORES SUGESTÃO
- 3.1.6. SOBRECARGA DE OPERADOR
- 3.2. CLASSES ABSTRATAS E CONCRETAS
- 3.2.1. CLASSE ABSTRATA ITERADOR................................................................
- 3.2.2. ACOPLAMENTO DE MENSAGENS
- 3.2.3. CONTAS BANCÁRIAS
- 3.2.4. LISTA HETEROGÊNEA DE CONTAS BANCÁRIAS.
- TÓPICOS AVANÇADOS
- 4.1. FRIENDS
- 4.1.1. UMA CLASSE PERMITINDO ACESSO A OUTRA
- 4.1.2. OPERADORES E FRIENDS...........................................................................
- 4.2. HERANÇA MÚLTIPLA.........................................................................................
- 4.2.1. UM EXEMPLO SIMPLES.
- 4.2.2. VIRTUAL PUBLIC E RESOLUÇÃO DE CONFLITOS................................
- 4.3. POLIMORFISMO PARAMÉTRICO (TEMPLATE).............................................
- 4.3.1. TAD VETOR....................................................................................................
- 4.3.2. TEMPLATE DE FUNÇÃO
- 4.3.3. HERANÇA E TEMPLATES.
- 4.3.4. TEMPLATES E AGREGAÇÃO
- 4.4. METACLASSES.....................................................................................................
- 4.4.1. UM TIPO SIMPLES COMO STATIC
- 4.4.2. UM TIPO DEFINIDO PELO USUÁRIO USADO COMO STATIC
- 4.5. TRATAMENTO DE EXCEÇÕES..........................................................................
- 4.6. CONCLUSÕES.......................................................................................................
- 4.6.1. ÁRVORE BINÁRIA.
- 4.6.2. SIMULAÇÃO DIRIGIDA A EVENTOS.
inteiros. A classe envolve, associa, funções e dados, controlando o acesso a estes, definí-la implica em especificar os seus atributos (dados) e suas funções membro (código). Um programa que utiliza uma interface controladora de um motor elétrico provavelmente definiria a classe motor. Os atributos desta classe seriam: temperatura, velocidade, tensão aplicada. Estes provavelmente seriam representados na classe por tipos como float ou long. As funções membro desta classe seriam funções para alterar a velocidade, ler a temperatura, etc. Um programa editor de textos definiria a classe parágrafo que teria como um de seus atributos uma string ou um vetor de strings, e como funções membro, funções que operam sobre estas strings. Quando um novo parágrafo é digitado no texto, o editor cria a partir da classe parágrafo um objeto contendo as informações particulares do novo texto. Isto se chama instanciação ou criação do objeto. Classes podem ser declaradas usando a palavra reservada struct ou a palavra reservada class, nos exemplos posteriores entraremos em mais detalhes. As classes do próximo tópico 1.2 são declaradas com struct por razões didáticas. Quando chegarmos em encapsulamento 1.3 mostraremos como declarar classes com class e não usaremos mais struct no tutorial.
1.1. ESPECIFICANDO UMA CLASSE
Suponha um programa que controla um motor elétrico através de uma saída serial. A velocidade do motor é proporcional a tensão aplicada, e esta proporcional aos bits que vão para saída serial e passando por um conversor digital analógico. Vamos abstrair todos estes detalhes por enquanto e modelar somente a interface do motor como uma classe, a pergunta é que funções e que dados membro deve ter nossa classe, e que argumentos e valores de retorno devem ter essas funções membro: Representação da velocidade: A velocidade do motor será representada por um atributo, ou dado membro, inteiro (int). Usaremos a faixa de bits que precisarmos, caso o valor de bits necessário não possa ser fornecido pelo tipo , usaremos então o tipo long , isto depende do conversor digital analógico utilizado e do compilador. Representação da saída serial: O motor precisa conhecer a sua saída serial, a sua ligação com o "motor do mundo real". Suponha uma representação em hexadecimal do atributo endereço de porta serial, um possível nome para o atributo: enderecomotor. Não se preocupe em saber como usar a representação hexadecimal. Alteração do valor da velocidade:
Internamente o usuário da classe motor pode desejar alterar a velocidade, cria-se então o método ( em C++ função membro): void altera_velocidade(int novav);. O código anterior corresponde ao cabeçalho da função membro, ela é definida junto com a classe motor, associada a ela. O valor de retorno da função é void (valor vazio), poderia ser criado um valor de retorno (int) que indicasse se o valor de velocidade era permitido e foi alterado ou não era permitido e portanto não foi alterado. Não faz sentido usar, chamar, esta função membro separada de uma variável do tipo motor, mas então porque na lista de argumentos não se encontra um motor? Este pensamento reflete a maneira de associar dados e código (funções) das linguagens procedurais. Em linguagens orientadas a objetos o código e os dados são ligados de forma diferente, a própria declaração de um tipo definido pelo usuário já engloba as declarações das funções inerentes a este tipo, isto será explicado em 1.2.2. Note que não fornecemos o código da função, isto não é importante, por hora a preocupação é com a interface definida pela classe: suas funções membro e dados membro. Apenas pense que sua interface deve ser flexível de modo a não apresentar entraves para a criação do código que seria feita numa outra etapa. Nesta etapa teríamos que imaginar que o valor numérico da velocidade deve ir para o conversor onde irá se transformar numa diferença de potencial a ser aplicada nos terminais do motor, etc. Um diagrama simplificado da classe motor com os dados membro e as funções membro: Exercícios: 1)Lembre-se de algum programa em que você trabalhou, cite que tipos de classes seriam criadas se esse programa fosse escrito em C++, que atributos e que funções membro estariam associadas a esses objetos? Exemplo: "Eu trabalhei em um programa de contas a pagar e contas a receber. Se esse programa fosse escrito em C++ eu definiria a classe conta_bancaria. Os atributos seriam: saldo, taxa_de_juros, limite_de_saque, etc. Minha opção seria por representá-los como variáveis do tipo float. " "Dentre as funções membros desta classe estariam funções para efetuar saques, depósitos e computar juros."
1.2. STRUCT EM C++
Objetos são instâncias de uma classe. Quando um objeto é criado ele precisa ser inicializado, ou seja para uma única classe : Estudante de graduação podemos ter vários objetos num programa: Estudante de graduação Carlos, Identificação 941218, Curso Computação; Estudante de graduação Luiza , Identificação 943249, Curso Engenharia
//colocando o circulo em uma posicao determinada cout << "Raio:"<<ac.raio <<endl; //verificacao dos atributos alterados. cout << "X:"<<ac.x << "\n"; // "\n"==endl cout << "Y:" <<ac.y<< endl; } Resultado do programa: Raio: X: Y: 1 Comentários: struct circulo //struct que representa um circulo. { float raio; float x; //posicoes em coordenadas cartesianas float y; }; Este código é a declaração da classe círculo, entre chaves vem os dados membro e as funções membro que não foram apresentadas ainda. A sintaxe para criação de objetos da classe círculo (circulo ac;) , por enquanto não difere da sintaxe para a criação de variáveis do tipo int. O acesso aos dados membro deve ser feito usando o nome do objeto e o nome do dado membro, separados por um ponto: ac.raio=10.0;. Note que raio sozinho não faz sentido no programa, precisa-se especificar de que objeto se deseja acessar o raio.
Aos que programam em C: Os programadores C podem notar algo interessante: "C++ não requer a palavra struct na declaração da variável, ela se comporta como um tipo qualquer: int , float ...". Outros programadores que não haviam usado struct previamente em C não se preocupem, façam apenas os exercícios deste exemplo e estarão aptos a prosseguir. Exercícios:
- Repita o mesmo exemplo só que agora mova o círculo alterando as componentes x e y. Ponha o círculo em (0.0,0.0) através de atribuições do tipo ac.x=1.0; mova o círculo para (1.0,1.0). Acompanhe todas as modificações da struct através de cout's. 2)Simplifique o programa anterior retirando o atributo raio. Você pode dar o nome de ponto ou ponto_geometico para esta classe.
1.2.2. MÉTODOS OU FUNÇÕES MEMBRO.
C++ permite que se acrescente funções de manipulação da struct em sua declaração, juntando tudo numa só entidade que é uma classe. Essas funções membro podem ter sua declaração (cabeçalho) e implementação (código) dentro da struct ou só o cabeçalho (assinatura) na struct e a implementação, código, fora. Este exemplo apresenta a primeira versão, o próximo a segunda versão (implementação fora da classe). Essas funções compõem a interface da classe. A terminologia usada para designá-las é bastante variada: funções membro, métodos, etc. Quando uma função membro é chamada, se diz que o objeto está recebendo uma mensagem (para executar uma ação). Um programa simples para testes sobre funções membro seria o seguinte: #include <iostream.h> struct contador //conta ocorrencias de algo { int num; //numero do contador void incrementa(void){num=num+1;}; //incrementa contador
A sintaxe de chamada ou acesso à funções membro é semelhante a sintaxe de acesso aos dados membro com exceção dos parênteses que contém a lista de argumentos da função, mesmo que a lista seja vazia eles devem estar presentes: umcontador.incrementa();. Primeiro insere-se o nome do objeto e depois a chamada da função, estes são separados por um ponto. Cuidado para não esquecer os parênteses nas chamadas de funções membro em programas futuros, este é um erro bastante comum. Agora o programa mais complicado, porém baseado no exemplo 1.2.1: #include <iostream.h> //para cout struct circulo { float raio; float x; //atributo coordenada cartesiana x float y; //atributo coordenada cartesiana y void move(float dx,float dy) //função membro ou função membro move { x+=dx; //equivale a x=x+dx; y+=dy; } void mostra(void) //função membro ou função membro mostra { cout << "Raio:"<<raio <<endl; cout << "X:"<<x << endl; cout << "Y:" <<y<< endl;
} }; void main() { circulo ac; // * instanciação de um objeto circulo (criacao) ac.x=0.0; ac.y=0.0; ac.raio=10.0; ac.mostra(); ac.move(1.0,1.0); ac.mostra(); ac.x=100.0; ac.mostra(); } Resultado do programa: Raio: X: Y: Raio: X: Y: Raio: X:
6)"Há uma tendência em definir o maior número de funções membro em uma classe, porque nunca se pode prever exatamente o seu uso em programas futuros". Comente esta frase, tendo em vista o conceito de portabilidade. Você já é capaz de citar outras medidas que tornem suas classes mais portáveis? Leia o exercício anterior.
1.2.3. FUNÇÕES MEMBRO QUE RETORNAM VALORES.
Até agora só tínhamos visto funções membro com valor de retorno igual a void. Uma função membro, assim como uma função comum, pode retornar qualquer tipo, inclusive os definidos pelo usuário. Sendo assim, sua chamada no programa se aplica a qualquer lugar onde se espera um tipo igual ou equivalente ao tipo do seu valor de retorno, seja numa lista de argumentos de outra função , numa atribuição ou num operador como o cout << variavel; #include <iostream.h> struct contador //conta ocorrencias de algo { int num; //numero, posicao do contador void incrementa(void){num=num+1;}; //incrementa contador void comeca(void){num=0;}; //comeca a contar, "reset" int retorna_num(void) {return num;}; }; void main() //teste do contador { contador umcontador; umcontador.comeca();
//nao esqueca dos parenteses, e uma funcao membro nao dado! cout << umcontador.retorna_num() << endl; umcontador.incrementa(); cout << umcontador.retorna_num() << endl; } Resultado do programa: 0 1
1.2.4. FUNÇÕES DECLARADAS EXTERNAS A CLASSE , FUNÇÕES
MEMBRO CHAMAMANDO FUNÇÕES MEMBRO.
Este exemplo apresenta a implementação, definição, das funções fora da declaração da struct. Além disso introduz uma nova função chamada "inicializa" e funções float retorna_raio(void); e void altera_raio(float a). Inicializa coloca o ponto nas coordenadas passadas como seus argumentos. Introduzimos esta função membro aqui para preparar a explicação sobre construtores dada no próximo exemplo: 1.2.6. Comentários: Em uma declaração de uma classe normalmente se coloca a declaração das funções membro depois da declaração dos atributos, porém podemos fazer intercalações ou adotar qualquer ordem que nos convenha. O programador não é obrigado a implementar as funções membro dentro da declaração da classe, basta defini-las e apresentar a implementação em separado segundo a sintaxe (compilável) descrita a seguir: #include <iostream.h> struct teste { int x; void altera_x(int v);
void inicializa(float ax,float by,float cr); void altera_raio(float a); float retorna_raio(void); void move(float dx,float dy); void mostra(void); }; void circulo::inicializa(float ax,float by,float cr) { x=ax; y=by; raio=cr; } void circulo::altera_raio(float a) { raio=a; } float circulo::retorna_raio(void) { return raio; } void circulo::move(float dx,float dy) { x+=dx; y+=dy; } void circulo::mostra(void)
{ cout << "Raio:"<< retorna_raio() <<endl; cout << "X:"<<x << endl; cout << "Y:" <<y<< endl; } void main() { circulo ac; ac.inicializa(0.0,0.0,10.0); ac.mostra(); ac.move(1.0,1.0); ac.mostra(); ac.x=100.0; ac.altera_raio(12.0); ac.mostra(); } Comentários: Observe que a função membro mostra chama a função membro float retorna_raio(void) que é da mesma classe. Fica implícito da definição de mostra que retorna_raio() se aplica ao mesmo objeto instanciado que recebeu a chamada de mostra, ou seja, não é necessário usar o. na chamada de retorna_raio(). Em programas maiores, chamadas aninhadas de funções membro são bastante comuns. Programação orientada a objetos e interfaces gráficas com o usuário: Existem "libraries" de classes que permitem o programador C++ desenvolver aplicações para ambientes como o Microsoft Windowsreg. de uma maneira bastante abstrata, este é um exemplo claro de reuso de código, afinal o programador não precisa saber de detalhes da interface para programar nela.
{COMPARACAO COM UM PROGRAMA C++} TYPE Circulo=RECORD x:real; {COORDENADAS X E Y} y:real; r:real; {somente dados} END; var ac:circulo; leitura:integer; PROCEDURE Inicializa(var altereme:Circulo;ax,by,cr:real); {COLOCA O CIRCULO EM DETERMINADA POSICAO} BEGIN altereme.x:=ax; altereme.y:=by; altereme.r:=cr; END; PROCEDURE Altera_Raio(var altereme:Circulo;ar:real); {ALTERA O RAIO DO CIRCULO} BEGIN altereme.r:=ar; END; FUNCTION Retorna_Raio(copieme:Circulo):real; BEGIN Retorna_Raio:=copieme.r; END;
PROCEDURE Move(var altereme:Circulo;dx,dy:real); {MODE AS COORDENADAS X E Y ACRESCENTANDO DX E DY} BEGIN altereme.x:=altereme.x+dx; altereme.y:=altereme.y+dy; END; PROCEDURE Mostra(copieme:Circulo); {MOSTRA O CIRCULO NA TELA} BEGIN writeln('X:',copieme.x,' Y:',copieme.y,' R:',copieme.r); END; BEGIN {TESTES} Inicializa(ac,0.0,0.0,10.0); Mostra(ac); Move(ac,1.0,1.0); Mostra(ac); ac.x:=100.0; Altera_Raio(ac,12.0); Mostra(ac); read(leitura); END. Resultado do programa: X: 0.0000000000E+00 Y: 0.0000000000E+00 R: 1.0000000000E+
