Estruturação de Linguagens de Programação (Pascal e C++)

3,413 views

Published on

Baixe mais arquivos em http://pastadomau.wikidot.com.
Este trabalho mostra de forma superficial (que modéstia!) os conceitos básicos de duas linguagens de programação: Pascal e C++. Os tópicos abordados são os básicos necessários para que um programador que desconheça a linguagem consiga elaborar um pequeno programa e compreender as principais características de cada linguagem. Entre os itens apresentados estão os tipos de dados oferecidos por cada uma das linguagens bem como o modo que cada uma trabalha com eles.

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
3,413
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
46
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Estruturação de Linguagens de Programação (Pascal e C++)

  1. 1. UNIVERSIDADE LUTERANA DO BRASIL CENTRO DE CIÊNCIAS EXATAS E NATURAIS CURSO DE SISTEMAS DE INFORMAÇÃOESTRUTURAÇÃO DE LINGUAGENS (PASCAL E C++) MAURICIO VOLKWEIS ASTIAZARA Paradigmas de Linguagem de Programação Torres, Agosto de 2001
  2. 2. SumárioLista de Tabelas.....................................................................................5Resumo..................................................................................................6Introdução..............................................................................................71 Pascal..................................................................................................8 1.1 Ambiente......................................................................................................8 1.1.1 Run..............................................................................................................................8 1.1.2 Compile.......................................................................................................................8 1.1.3 Debug..........................................................................................................................9 1.2 Tipos de Dados.............................................................................................9 1.2.1 Tipos de Dados Inteiros ..............................................................................................9 1.2.2 Tipos de Dados Reais..................................................................................................9 1.2.3 Tipos de Dados Caracteres........................................................................................10 1.2.4 Tipos de Dados Lógicos............................................................................................10 1.3 Variáveis.....................................................................................................10 1.3.1 Regras para Nomeação..............................................................................................10 1.3.2 Declaração.................................................................................................................11 1.3.3 Escopo.......................................................................................................................12 1.3.4 Comando de Atribuição.............................................................................................12 1.4 Constantes...................................................................................................12 1.5 Operadores Aritméticos..............................................................................13 1.6 Operadores Relacionais..............................................................................13 1.7 Operadores Lógicos....................................................................................14 1.8 Estrutura de um Programa..........................................................................14 1.8.1 Cabeçalho..................................................................................................................14 1.8.2 Área de Declarações..................................................................................................14 1.8.3 Corpo de Programa....................................................................................................15 1.9 Comandos de Entrada e Saída....................................................................15 1.10 Comentários..............................................................................................16 1.11 Desvio Condicional..................................................................................17 2
  3. 3. 1.11.1 Simples....................................................................................................................17 1.11.2 Composto.................................................................................................................17 1.12 Iteração.....................................................................................................18 1.13 Procedimentos e Funções.........................................................................18 1.13.1 Unidades Padrão......................................................................................................18 1.13.2 Procedures...............................................................................................................19 1.13.3 Function...................................................................................................................21 1.14 Construindo uma Biblioteca de Rotinas...................................................22 1.14.1 Estrutura de uma Unit..............................................................................................222 C++...................................................................................................24 2.1 Introdução à Orientação ao Objeto.............................................................24 2.1.2 Encapsular e esconder...............................................................................................24 2.1.3 Herança......................................................................................................................24 2.2 Tipos de Dados...........................................................................................25 2.3 Variáveis.....................................................................................................26 2.3.1 Regras para Nomes de Variáveis...............................................................................26 2.3.2 Declarações de Variáveis..........................................................................................27 2.3.3 Operador de Atribuição.............................................................................................27 2.3.4 Inicializando Variáveis..............................................................................................28 2.4 Constantes...................................................................................................28 2.4.1 Constantes Numéricas...............................................................................................28 2.4.2 Cadeia de Caracteres Constante................................................................................28 2.4.3 O Qualificador const.................................................................................................28 2.5 Operadores Aritméticos..............................................................................29 2.5.1 Operadores Aritméticos Básicos...............................................................................29 2.5.2 Operadores de Incremento e Decremento.................................................................29 2.5.3 Operadores Aritméticos de Atribuição......................................................................30 2.6 Operadores Relacionais..............................................................................30 2.7 Operadores Lógicos....................................................................................30 2.8 Estrutura de um Programa..........................................................................31 2.8.1 Forma geral das funções C++....................................................................................31 3
  4. 4. 2.8.2 O Primeiro Programa.................................................................................................31 2.9 Comandos de Entrada e Saída....................................................................33 2.9.1 Imprimindo Usando cout...........................................................................................33 2.9.2 Lendo com cin e o Operador de Extração.................................................................35 2.10 Comentários..............................................................................................36 2.11 Desvio Condicional..................................................................................36 2.12 Procedimentos e Funções.........................................................................37 2.13 Classes......................................................................................................38Conclusão............................................................................................40Referências Bibliográficas..................................................................41 4
  5. 5. Lista de Tabelas 5
  6. 6. Resumo Este trabalho mostra de forma superficial os conceitos básicos de duas linguagens de programação: Pascal eC++. Os tópicos abordados são os básicos necessários para que um programador que desconheça a linguagemconsiga elaborar um pequeno programa e compreender as principais características de cada linguagem. Entre ositens apresentados estão os tipos de dados oferecidos por cada uma das linguagens bem como o modo que cadauma trabalha com eles. Abstract This work show on surface form the basic concepts about two programming languages: Pascal and C++. Theapproached topics are needed and basic for a programmer who unknow the language can to make a smallprogram and to understand main characteristcs from each language. Into presents itens there are data types fromeach language and the way how each work with it. 6
  7. 7. Introdução Para escolhermos um linguagem de programação precisamos de certos conhecimentos básicos sobre cadauma, para que se possa fazer uma avaliação sobre qual é a mais adequada para determinado trabalho ou projeto.Este trabalho pretende mostrar de forma breve uma introdução às linguagens de programação Pascal e C++, como objetivo de destacar as principais características e para que se tenha uma base mínima das possibilidades decada linguagem. 7
  8. 8. 1 Pascal 1.1 Ambiente O ambiente Turbo Pascal integra todos os recursos de um compilador com um editor de textos. O Turbo Pascal possui um menu de comandos com 10 opções que possibilitam executar diversas tarefasoperacionais. Existem 3 formas de acessar os menus: 1. Tecla F10 seguida do uso de teclas direcionais 2. Alt+ a letra grafada em maiúsculo 3. Mouse através de clique simples As funções de editor de texto não serão mencionadas por se tratarem de funções padrão da maioria doseditores de textos, como manipulação de arquivos (novo, abrir, salvar, etc.) e edição do texto (copiar, localizar,substituir, etc). Serão focalizadas as funções de compilação e depuração de programas, que estão presentes nosmenus que seguem: 1.1.1 Run Esta opção possibilita colocar em execução o programa da janela ativa. Desta forma é possível: • Rodar todo o programa (Run) • Rodar o programa passo a passo com exceção das subrotinas existentes (Step Over) • Rodar o programa passo a passo inclusive com as subrotinas (Trace Into) • Rodar o programa até a posição do cursor (Go to Cursor) • Interromper a execução de um programa durante a sua depuração (Program Reset) • Efetuar a passagem de parâmetros (Parameters) 1.1.2 Compile Esta opção possibilita compilar o programa. Desta forma, é possível: • Compilar o programa da janela ativa (Compile) • Recompilar apenas os programas alterados (Make) • Recompilar todos os programas (Build) • Determinar se o programa será compilado somente em memória ou disco (Destination) • Determinar numa lista de arquivo qual será o principal que será carregado primeiro no processo de compilação (Primary File) • Obter informações a respeito da última compilação executada (Information) 8
  9. 9. 1.1.3 Debug Esta opção possibilita depurar o programa para facilitar a localização de erros lógicos. Desta forma épossível: • Colocar ou retirar um ponto de parada (exame) quando da depuração de um programa (Breakpoint) • Apresentar uma janela com a seqüência de chamadas efetuadas de subrotinas (Call Stack) • Abrir a janela de acompanhamento de valores nas variáveis do programa (Watch) • Abrir uma janela para apresentar as telas de saída do programa em execução ou depuração (Output) • Exibir em sua totalidade a tela do usuário (User Screen) • Permite avaliar expressões, constantes ou variáveis (Evaluate/modify) • Possibilidade de se incluir expressões na tela de vigia (Add Watch) • Permite a inclusão de um ponto de parada quando for executado o programa (Add Breakpoint) 1.2 Tipos de dados Os dados são representados pelas informações a serem processadas por um computador. A linguagem Pascalfornece ao programador um conjunto de tipos de dados predefinidos, podendo estes ser dos tipos numéricos(inteiros e reais), caracteres e lógicos. 1.2.1 Tipos de Dados Inteiros São caracterizados tipos inteiros de dados os dados numéricos positivos ou negativos excluindo-se qualquernúmero fracionário. Em Pascal este tipo de dado pode ser referenciado por um destes identificadores: Tabela 1: Tipos de dados inteiros em Pascal Tipo de Dado Inteiro Faixa de Abrangência Shortint De –128 até 127 Integer De –32.768 a 32.767 Longint De –2.147.483.648 até 2.147.483.647 Byte De 0 até 255 Word De 0 a 65.535 1.2.2 Tipos de Dados Reais São caracterizados tipos de dados reais os dados numéricos positivos, negativos, inteiros e fracionários. EmPascal este tipo de dado pode ser referenciado por um dos seguintes identificadores: Tabela 2: Tipos de dados reais em Pascal Tipo de Dado Real Faixa de Abrangência Real De 2,9 E-39 até 1,7 E+38 Single De 1,5 E-45 até 3,4 E+38 9
  10. 10. Double De 5,0 E-324 até 1,7 E+308 Extended De 3,4 E-4.932 até 1,1 E+4.932 Comp De –9,2 E+18 até 9,2 E+18 Este tipo de dado permite trabalhar com uma representação de valores em ponto flutuante que consiste deuma mantissa (parte fracionária). O tipo single usa uma mantissa de 7 a 8 dígitos, o tipo real usa uma mantissa de11 dígitos, o tipo double usa uma mantissa de 15 a 16 dígitos e os tipos extended e comp utilizam um mantissade 19 a 20 dígitos. 1.2.3 Tipos de Dados Caracteres São caracterizados tipos caracteres as seqüências contendo letras, números e símbolos especiais. Umaseqüência de caracteres deve ser representada entre apóstrofos ( ‘ ‘ ) também chamados de aspas simples.Exemplo da representação de uma cadeia de caracteres: ‘Blaise Pascal (1623-1662): filósofo e matemático francês.’ Este tipo de dado é referenciado pelo identificador string podendo armazenar de 1 a 255 caracteres. Existeainda o tipo char, utilizado da mesma forma que o tipo string, porém armazena apenas um caractere. 1.2.4 Tipos de Dados Lógicos São caracterizados tipos lógicos os dados com valores True (verdadeiro) ou False (falso), sendo que este tiposomente poderá apresentar um desses valores. Este tipo também é chamado tipo booleano. Este tipo de dado éreferenciado pelo identificador boolean. 1.3 Variáveis Variável é, no sentido de programação, uma região de memória de um computador, previamente identificadae que tem por finalidade armazenar informações (dados) de um programa temporariamente. Uma variávelarmazena apenas um valor por vez. Sendo considerado como valor o conteúdo de uma variável, desta forma, umvalor está relacionado ao tipo de dado de uma variável, podendo ser um valor numérico, lógico ou caractere. 1.3.1 Regras para Nomeação O nome de uma variável é utilizado para sua identificação e posterior uso dentro de um programa, sendoassim, é necessário estabelecer algumas regras para sua utilização: • O nome de uma variável deve ser atribuído com um ou mais caracteres; • O primeiro caractere não poderá ser um número, somente letra; • O nome não pode possuir espaços em branco; 10
  11. 11. • Não poderá ser nome de variável uma palavra reservada da linguagem Pascal; • Não poderão ser utilizados outros caracteres a não ser letras e números, com exceção do caractere underscore “_”, que poderá ser utilizado para simular a separação de palavras. Exemplos de nomes de variáveis válidos: A1 A2 Nome_Cliente Todo dado a ser armazenado na memória deve ser previamente declarado ou seja, primeiro é necessário saberqual o seu tipo para depois fazer o seu armazenamento. Estando armazenado o dado este poderá ser utilizado emanipulado a qualquer momento durante a execução do programa. 1.3.2 Declaração A área var é utilizada na declaração das variáveis que serão utilizadas durante a execução do programa, bemcomo o seu tipo. Desta forma é efetuada uma reserva de memória para que as variáveis sejam utilizadas. Adeclaração de variáveis é feita pela instrução var seguida da relação de variáveis. A relação de variáveis écomposta do nome de cada variável seguido de dois pontos ( : ) , seu tipo e ponto e vírgula. Comoesquematizado abaixo: Var <nome da variável 1> : <tipo da var 1>; <nome da variável 2> : <tipo da var 2>; <nome da variável N> : <tipo da var N>; Exemplo: Var Nome: string; Idade: integer; Altura: real; Caso sejam do mesmo tipo, as variáveis poderão ser declaradas na mesma linha separadas por vírgula: Var A, B, C: integer; Nome1, Nome2: string; 11
  12. 12. Importante observar que Pascal não diferencia letras maiúsculas de minúsculas. Sendo as expressões abaixo onome da mesma variável: NOME Nome 1.3.3 Escopo Uma variável é considerada global quando é declarada no início do programa podendo ser utilizada porqualquer subrotina subordinada. Uma variável é local quando é declarada dentro de uma subrotina e é somenteválida dentro da rotina onde está declarada. 1.3.4 Comando de Atribuição Para colocar um valor em uma variável utiliza-se o comando de atribuição simbolizado pelo dois pontos e umsinal de igual (:=). Possui a seguinte sintaxe: <nome da variável> := <expressão>; Onde expressão pode ser uma constante (diretamente um valor) ou uma expressão de cálculo. A expressão ouo seu resultado deve ser do mesmo tipo da variável. Exemplos: A:=5; Nome:=’Blaise Pascal’; 1.4 Constantes Tem-se como definição de constante aquilo que é fixo ou estável. Um valor constante pode ser diretamentemencionado no código: A:=5; Nome:=’Blaise Pascal’; Porém, em certos programas seja mais vantajoso o uso de alguns identificadores de constante. A área const é usada para a declaração de identificadores que representam valores constantes durante todo oprograma. Exemplo: Const PI= 3.141592; 12
  13. 13. Ap= ’Sistema Integrado de Cálculo de Geometria Espacial’; Voltas=10; O uso de identificadores de constante tem vantagens sobre o uso direto dos valores quando o valor é muitousado e ao mesmo tempo tem grande extensão de caracteres (como o PI) ou é freqüentemente alterado para finsde teste do programa. 1.5 Operadores Aritméticos Para a construções de expressões matemáticas na linguagem Pascal, utilizamos os seguintes operadores: Tabela 3: Operadores Aritméticos em Pascal Operador Descrição * Multiplicação / Divisão real Div Divisão inteira Mod Resto da divisão inteira + Adição - Subtração Contamos ainda com o auxilio de parênteses para indicar precedência (prioridade de cálculo). Veremos umexemplo de expressão matemática transformada para Pascal: Na matemática: A=5+1+2B 2 Em Pascal: A:=(5+1)/2+2*B; 1.6 Operadores Relacionais Os operados são relacionais são usados para comparar valores. Com elas é possível criar uma expressão queindica uma afirmação. O resultado é a confirmação ou negação da expressão através de um valor booleano (vistoanteriormente). Os operadores relacionais são os seguintes: Tabela 4: Operadores relacionais em Pascal Símbolo Significado = Igual a <> Diferente de > Maior que < menor que >= Maior ou igual <= Menor ou igual 13
  14. 14. Os operadores relacionais podem comparar valores numéricos (inteiros e reais) e caracteres (através do valordo caracter na tabela ASCII). Por retornarem um valor booleano podem ser armazenados numa variável do tipoboolean: Var a, b: boolean; ... a:=20>10; b:=’A’>’B’; Neste exemplo a variável “a” receberia o valor True e “b” o valor False. 1.7 Operadores Lógicos Conhecidos também como operadores booleanos, fazem cálculos seguindo a matemática booleana, sendoassim só operam com dados do tipo boolean. São os seguintes: Tabela 5: Operadores lógicos em Pascal Operador Lógica Not Retorna o oposto do valor. Este é o único operador unário. And Retorna Verdadeiro somente se todos os valores forem Verdadeiros Or Retorna Falso somente se todos os valores forem Falsos Xor Retorna Verdadeiro se os valores forem diferentes 1.8 Estrutura de um Programa Veremos a seguir as principais partes de um programa, na respectiva ordem em que devem aparecer. 1.8.1 Cabeçalho Consiste na identificação do programa. As regras para nomes de programa são as mesmas da nomeação devariáveis. Não poderá haver variável com o mesmo nome do programa. O cabeçalho é atribuído pela instruçãoprogram seguida nome e de um ponto e vírgula (;) como abaixo: Program Calculo; 1.8.2 Área de Declarações É utilizada para validar o uso de qualquer tipo de identificador que não seja predefinido, estando estasubdividida em sete subáreas: Uses Label 14
  15. 15. Const Type Var Procedure Function 1.8.3 Corpo de Programa No corpo do programa estão as instruções que serão executadas no programa. Esta área tem início com ainstrução begin e é finalizada com a instrução end seguida de ponto final (.). O uso dessas duas instruçãocaracteriza o que é chamado de bloco de comandos, como indicado abaixo: Begin <instrução 1>; <instrução 2>; <instrução N>; End. 1.9 Comandos de Entrada e Saída Os comandos de saída de dados mais utilizados para impressão em vídeo são: write e writeln. Possuem aseguinte sintaxe: Write(<expressões>); Writeln(<expressões>); Onde <expressões> é um conjunto de dados a serem impressos, separados por vírgula. Exemplos: Writeln(‘Saída em vídeo’); Write(2001); Assumindo que “media” seja uma variável que contém a média de duas outras variáveis “A” e “B” : Write(‘Resultado da média entre ‘, A, ‘ e ‘, B, ‘ é ‘, media); A diferença entre write e writeln é que o comando writeln após imprimir os dados acrescenta uma novalinha. O write mantém o cursor na mesma linha. O writeln pode ser usado para imprimir uma linha em branco,bastando usá-lo sem uma expressão para ser impressa. Exemplo: Write(1); 15
  16. 16. Write(2); Writeln(3); Writeln; Writeln(‘Exemplo de uso de saída em vídeo’); A saída destes comandos na tela é a seguinte: 123 Exemplo de uso de saída em vídeo Para a leitura de dados via teclado são utilizados os comandos read e readln. Possuem sintaxe semelhante àdos comandos de saída: Read(<variáveis>); Readln(<variáveis>); Onde variáveis é um conjunto de variáveis separadas por vírgula. Quando um desses comandos é encontrado,a execução do programa é interrompida aguardando a entrada dos dados que é confirmada com a tecla ENTER.Exemplo: Writeln(‘Entre com o valor:’); Readln(valor); Writeln(‘Digite as três notas:’); Readln(a, b, c); Para leitura de mais de uma variável, como mostrado acima, os valores podem ser separados por espaço efinalizados com um ENTER ou individualmente com um ENTER para cada valor. 1.10 Comentários As linguagens sempre oferecem um meio de inserir comentários em códigos fonte para fins de documentaçãoe aumentar facilidade de entendimento do programa. Em Pascal os comentários devem estar entre chaves ( { } ).Os comentários podem Ter mais de uma linha. Exemplo: Writeln(‘Código comentado é mais inteligível.’); {mensagem para usuário. Pode ser alterada futuramente} Writeln(‘Fim’); {fim do programa} 16
  17. 17. 1.11 Desvio Condicional 1.11.1 Simples A instrução if ... then tem por finalidade tomar uma decisão e efetuar um desvio no processamento,dependendo da condição atribuída ser Verdadeira ou Falsa. Sendo a condição verdadeira, será executada ainstrução que estiver escrita após a instrução if ... then. Esta instrução como a maioria dos comandos em Pascal édelimitado por um ponto e vírgula. Caso seja necessário executar mais de uma instrução para a condiçãoverdadeira, estas deverão estar mencionadas dentro de bloco, que é definido com as instruções begin e end. If <valor booleano> then <instrução para valor verdadeiro>; If <valor booleano> then Begin <instrução 1>; <instrução 2>; <instrução N>; end; 1.11.2 Composto O desvio condicional simples executa um comando se o valor booleano for verdadeiro. Já o desviocondicional composto executa um comando se o valor for verdadeiro e outro comando se o valor for falso.Possui a seguinte sintaxe: If <valor booleano> then <comando para valor verdadeiro> else <comando para valor falso>; If <valor booleano> then begin <comando 1>; <comando 2>; <comando N>; end else begin <comando 1>; 17
  18. 18. <comando 2>; <comando N>; end; 1.12 Iteração A estrutura de iteração, também chamada de laço ou looping caracteriza-se por executar um determinadotrecho de instruções enquanto uma determina expressão for verdadeira (True). Uma das estruturas de laçooferecidas pela linguagem Pascal é o while (enquanto) e possui a seguinte sintaxe: While <valor booleano> do <instrução para valor verdadeiro>; Para mais de uma instrução no laço é necessário o uso de um bloco de comandos, através do uso de begin eend. Exemplo: While a<>10 do begin writeln(a); a:=a+1; end; Existe ainda outra estrutura de laço no Pascal chamada for. Este tipo de laço exige uma variável com umvalor inicial. A cada iteração acrescenta 1 a esta variável. O loop só termina quando a variável possuir valorigual ao valor final. O for é apropriado somente para laços que sejam guiados por uma contagem: For <variável>:=<valor inicial> to valor <valor final> do <instrução>; 1.13 Procedimentos e Funções A utilização de sub-rotinas é a base da programação estruturada (ou modularizada). A linguagem Pascalpermite a construção de sub-rotinas de dois tipos: Procedures (procedimentos) e Function (função). A diferençaentre as duas é que a função retorna um valor. 1.13.1 Unidades Padrão 18
  19. 19. Além de permitir a construção de rotinas, existe ainda um conjunto de rotinas prontas, ou seja, oferecidaspela Borland. Estas rotinas estão agrupadas em bibliotecas, chamadas units. O Turbo Pascal passou a incorporaro conceito de units a partir da versão 4. A seguir as principais units: Tabela 6: Principais unidades padrão em Pascal Unit Descrição CRT Possui rotinas de geração de som, controle de vídeo e teclado. DOS Rotinas que envolvem a utilização do sistema operacional, na maior parte das vezes permitindo controles de baixo nível GRAPH Esta unidade possui rotinas destinadas à manipulação da capacidade gráfica do computador OVERLAY Permite gerenciar as atividades de um programa, desta forma é possível aproveitar uma mesma área de memória para rodar várias rotinas diferentes, economizando memória. PRINTER Esta unidade permite declarar um arquivo do tipo texto com o nome LST e associá-lo à impressora. SYSTEM Contém a maior parte das rotinas padrão da linguagem Pascal, não necessitando ser citada para ser usada, pois já executada de forma automática. Para utilizar as unidades utiliza-se o comando uses seguido das units que serão utilizadas, separadas porvírgula. Por exemplo: Uses CRT; Ou Uses CRT, PRINTER, GRAPH; 1.13.2 Procedures Como visto, as subrotinas podem ser implementadas através de procedures. As procedures são blocos decomandos que são executados somente quando chamados pelo programa principal ou por outra rotina. A sintaxe de uma procedure é a seguinte: Procedure <nome> [(<parâmetros>)]; Var <variáveis>; begin <comandos>; end; onde: • nome: é o nome da procedure; 19
  20. 20. • parâmetros: valores que a procedure necessita para realizar sua tarefa. Estes valores são passados pela rotina que chamou a procedure; • variáveis: declaração das variáveis que serão utilizadas na procedure. Estas variáveis são locais, sendo válidas somente dentro da procedure; • comandos: quaisquer comandos necessários para a implementação da procedure. Procedure Linha; Var i : integer; Begin i:=1; While i<>81 do Begin Writeln(‘_’); i:=1+1; End; End; Para chamar uma procedure simplesmente utiliza-se o seu nome seguido dos parâmetros (se o procedimentorequerer, utilizando vírgulas para separá-los) entre parentêses e ponto e vírgula. Exemplo: Linha; ExibeDados; Potencia(10, 2); Assim o ponto de execução do programa passará para a procedure. Ao término do procedimento, o ponto deexecução passa ao próximo comando que está logo após a chamada da procedure. Parâmetros Para que uma procedure receba valores como parâmetro é necessária a declaração de variáveis quearmazenem estes valores. Esta declaração segue as mesmas regras da declaração de variáveis, o nome davariável e seu tipo. Os parâmetros tem o mesmo escopo e comportamento das variáveis locais da procedure. Existem dois tipos de passagem de parâmetros: por valor e por referência. • Por Valor A passagem de parâmetros por valor caracteriza-se por efetuar uma cópia do valor que está sendo passadopara a variável que recebe o valor. A declaração de parâmetros por valor é feita da seguinte forma: Procedure fatorial (n: integer); 20
  21. 21. A passagem por valor permite que a procedure seja chamada diretamente com valores constantes ou comvariáveis, como abaixo: Fatorial (10); A:=10; Fatorial (A); • Por Referência A passagem de parâmetros por referência exige que quando a procedure for chamada, os parâmetros sejampassado através de uma variável, não sendo permitido o uso direto de uma constante. Na passagem por referêncianão é efetuada uma cópia do valor e sim do endereço de memória da variável. Isso faz com que qualquermanipulação do valor do parâmetro dentro da procedure seja refletida na variável da rotina que chamou aprocedure, pois se trarar na realidade da mesma variável. Para que uma variável receba valores por referencia énecessário o uso de var na sua declaração. Quadrado (var n: integer); 1.13.3 Function Assim como a procedure, a function é um bloco de comandos e todas as regras para procedures são válidastambém para as functions. A sua diferença em relação à procedure é que a function sempre um retorna um valor.O valor de uma função é retornado no seu próprio nome. O tipo de valor que uma function retorna é determinadona sua declaração, como segue: Function <nome> [(<parâmetros>)]: <tipo>; Var <variáveis> begin <comandos> end; Onde tipo é tipo de dado que a função retorna. Para executar o retorno da função utiliza-se em algummomento do bloco de comandos (entre o begin e o end) deverá haver um comando de atribuição ao nome dafunção: <nome da função>:=<valor>; 21
  22. 22. Se mais de um retorno for dado à função em momentos diferentes somente o último prevalecerá. Apesar deutilizar o comando de atribuição de forma semelhante à uma variável, não poderá ser feita a leitura da funçãodentro dela mesma mesmo que um valor já tenha sido atribuído à ela. A tentativa de leitura do valor da funçãodentro dela mesma caracteriza uma chamada recursiva, que se não tratada corretamente provocará um erro deestouro de pilha. Se nenhum valor for atribuído à função até o seu término ela poderá retornar um “lixo de memória”. Vejamos um exemplo de função: function Potencia (base: integer;expo: integer):integer; var i,p :integer; begin p:=1; for i:=1 to expo do p:=p*base; potencia:=p; end; 1.14 Construindo uma Biblioteca de Rotinas Ao longo de um programa observa-se que se certos problemas e situações se repetem, requerendo o mesmotrecho de código para sua solução. Isto pode ser facilitado com a construção de rotinas e funções para oprograma, mas muitas vezes esses problemas aparecem em programas diferentes. Pode-se copiar o código fontede um programa para outro, mas existe uma forma mais inteligente fornecida pelo Pascal. Consiste em juntar umgrupo de funções genéricas em uma biblioteca chamada unit (unidade). Desta forma um programa pode utilizar estas funções sem ter que escrevê-las novamente, simplesmentemencionando a unit na área de declaração uses. 1.14.1 Estrutura de uma Unit Fisicamente uma unit é um arquivo com extensão tpu (Turbo Pascal Unit). Para criar uma unit inicia-se umnovo arquivo, porém ao invés de program é utilizado a declaração unit. Logo após está a área interface. Nelaestão as declarações de todas as funções contidas na unit que são públicas, ou seja, utilizáveis pelo programadorque mencionar (através de uses) a unidade em seu programa. Na área implementation contém o código de todasas rotinas mencionadas na parte de interface Unit <nome>; Interface <declaração do rotina 1> <declaração da rotina 2> 22
  23. 23. <declaração da rotina N> implementation <rotina 1> <rotina 2> <rotina N> end. Uma vez codificada a unit deve ser compilada para o disco, o que gerará um arquivo .tpu. As units nãopodem ser diretamente executadas. 23
  24. 24. 2 C++ 2.1 Introdução à Orientação ao Objeto A idéia fundamental de linguagens orientadas ao objeto é a possibilidade de combinar num único registrocampos que conterão dados e campos que conterão funções para operar os campos de dados do registro. Umaunidade assim é definida como classe. Uma classe é considerada um tipo de dado como os outros tipos que existem predefinidos em compiladoresde diversas linguagens de programação. Como exemplo, considere o tipo int que é predefinido em C e C++. Podemos declarar quantas variáveis dotipo int forem necessárias ao programa. De modo similar, podemos declarar quantas variáveis quisermos de umaclasse já definida. Uma variável de uma classe é chamada objeto e conterá campos de dados e funções. Definir uma classe não cria nenhum objeto, do mesmo modo que a existência de um tipo int não crianenhuma variável. As funções de um objeto são chamadas funções-membro ou métodos e, de modo geral, são o único meio deacesso aos campos de dados também chamados de variáveis de instância. 2.1.2 Encapsular e esconder Se o programa necessita atribuir um valor a alguma variável de instância, deve chamar uma função membroque recebe o valor como argumento e faz a alteração. Não podemos acessar variáveis de instância diretamente. Desta forma, os campos de dados estarão escondidos para nós, o que previne alterações incidentais. Dizemosentão que os campos de dados e suas funções estão encapsulados (de cápsula) numa única identidade. As palavras encapsular e esconder são termos técnicos da definição de linguagens orientadas ao objeto. Se alguma modificação ocorrer em variáveis de instância de um certo objeto, sabemos exatamente quefunções interagiram com elas: são as funções-membro do objeto. Nenhuma outra função pode acessar essesdados. Isso simplifica a escrita, manutenção e alteração de programas. Um programa em C++ consiste em um conjunto de objetos que se comunicam por meio de funções-membro. A frase “chamar uma função membro de um objeto” pode ser dita como “enviar uma mensagem a umobjeto”. 2.1.3 Herança A programação orientada ao objeto oferece uma maneira de relacionar classes umas com as outras por meiode hierarquias. No nosso dia a dia, esse processo está presente quando dividimos classes em subclasses, mantendo oprincípio de que cada subclasse herda as características da classe da qual foi derivada. Por exemplo a classe de 24
  25. 25. animais é dividida nas subclasses mamíferos, aves, peixes, etc. uma das características da classe animais é areprodução. Todas as subclasses têm essa característica. Além das características herdadas, cada subclasse tem suas características particulares. Classe Base e Classes Derivadas: Características AB Características Características Características ABCD ABEF ABCFG Em programação orientada a objeto, o conceito de subclasse ou processo de classes derivadas é chamadoherança. Em C++, a classe de origem é chamada classe base e as classes que compartilham as características de umaclasse base e têm outras características adicionais são chamadas classes derivadas. Uma classe-base representa os elementos comuns a um grupo de classes derivadas. Você poderia pensar em herança como algo semelhante ao uso de funções para simplificar tarefastradicionais. Você escreve uma função quando identifica várias seções diferentes de um programa, em parteexecutem a mesma coisa. Em C++, você define uma classe-base quando identifica características comuns em um grupo de classesderivadas. Da mesma forma que você pode criar uma biblioteca de funções úteis a diversos programas, pode formaruma biblioteca de classes que poderão vir a ser o núcleo de muitos programas. O uso de uma biblioteca de calsses oferece uma grande vantagem sobre o uso de uma biblioteca de funções:o programador pode criar classes derivadas de classes base de biblioteca. Isto significa que, sem alterar a classebase, é possível adicionar a ela características diferentes que a tornarão capaz de executarmos exatamente o quedesejarmos. Um classe que é derivada de uma classe base pode, por sua vez, ser a classe base de outra classe. O uso de classes derivadas aumenta a eficiência da programação pela não necessidade da criação de códigosrepetitivos. A uma função de biblioteca não podemos adicionar outras implementações a não ser que ela sejareescrita ou que tenhamos o seu código fonte para alterá-la e recompilá-la. A facilidade com que classes existentes podem ser reutilizadas sem serem alteradas é um dos maioresbenefícios por linguagens orientadas ao objeto. 2.2 Tipos de Dados 25
  26. 26. O tipo de uma variável informa a quantidade de memória, em bytes que a variável ocupará e a forma como ovalor será armazenado e interpretado. Em C++, existem cinco tipos básicos de variáveis. Tabela 7: Tipos de dados em C++ Tipo Bytes Escala Char 1 -128 a 127 Int 2 -32.768 a 32.767 Float 4 3,4E-38 a 3,4E+38 Double 8 1,7E-308 a 1,7E+308 Void 0 Nenhum valor Com exceção do tipo void, os tipos de dados básicos podem se acompanhados por modificadores nadeclaração de variáveis. Os modificadores de tipo oferecidos por C++ são: • Long • Short • Unsigned Um modificador de tipo pode ser utilizado sem que seja especificado o tipo de variável. Quando isso é feito,o compilador assume que o tipo é int. Os modificadores podem ser utilizados com os tipos e as escalas descritos na tabela a seguir: Tabela 8: Modificadores em C++ Tipo Bytes Escala Unsigned char 1 0 a 255 Unsigned 2 0 a 65.535 Short 2 -32.768 a 32.767 Long 4 -2.147.483.648 a 2.147.483.647 Unsigned long 4 0 a 4.294.967.295 Long double 10 3,4E-4932 a 1,1E+4932 O tipo int tem sempre o tamanho da palavra da máquina, isto é, em computadores de 16 bits ele terá 16 bitsde tamanho. 2.3 Variáveis As variáveis são o aspecto fundamental de qualquer linguagem de programação. Uma variável em C++ é um espaço de memória reservado para armazenar um certo tipo de dado e tendo umnome para referenciar o seu conteúdo. O espaço de memória ocupado por uma variável pode ser compartilhado por diferentes valores segundoscertas circunstâncias. Em outras palavras uma variável é um espaço de memória que pode conter, a cada tempo,valores diferentes. 2.3.1 Regras para Nomes de Variáveis • É permitido nome para variáveis com até 32 caracteres. 26
  27. 27. • Caso haja mais caracteres que isso eles serão ignorados. • O nome pode conter letras maiúsculas e minúsculas, dígitos e sublinhado (underscore) • Obrigatoriamente o primeiro caracter deve ser uma letra ou um sublinhado • Letras maiúsculas e minúsculas são diferentes • Não pode ser o nome de uma palavra reservada do C++. 2.3.2 Declarações de Variáveis Uma declaração de variável consiste na identificação do seu tipo, seguida do nome e ponto e vírgula. As seguintes instruções Int num1; Int num2; São exemplos de declaração de variáveis, isto é, apresentam um tipo int e um nome para acessar o seuconteúdo. Em C++ todas as variáveis devem ser declaradas. As variáveis devem ser declaradas antes de serem usadasno programa. Uma variável pode ser declarada em qualquer lugar do programa. Se haver mais de uma variável do mesmo tipo elas poderão ser declaradas juntas, separando os nomes porvírgula. Exemplo: Int avião, foguete, helicoptero; 2.3.3 Operador de Atribuição O sinal de igual (=) representa a atribuição da expressão à sua direita à variável à sua esquerda. Exemplo: X=2000; Atribui o valor 2000 à variável de nome X. A ação é executada da direita para a esquerda. Toda expressão em C++ tem um valor. A expressão 5+2 tem valor 7. A expressão X=3 tem valor 3. Uma expressão de atribuição tem o valor atribuído. Sendo assim é permitido escrever Y=X=3 Lembrando que as atribuições são executadas da direita para esquerda, a expressão anterior poderia serescrita Y=(X=3) 27
  28. 28. Tanto X quanto Y terão valor 3. Este tipo de expressão é chamada atribuição múltipla. 2.3.4 Inicializando Variáveis É possível combinar uma declaração de variável com o operador de atribuição para que a variável tenha umvalor inicial ao mesmo tempo de sua declaração. Vejamos um exemplo que cria três variáveis e as inicializa: int evento=5; char corrida=’C’; float tempo=27.25; 2.4 Constantes Uma constante tem valor fixo e inalterável. Elas podem ser representadas diretamente pelo seu valor ou poridentificadores definidos pelo programador. 2.4.1 Constantes Numéricas Números constantes em C++ podem ser escritos nas seguintes bases numéricas: Tabela 9: Representação das bases numéricas em C++ Base Representação Decimal Escrevemos um número em decimal de forma pura e simples, como aquela que estamos acostumados. Ex.: 20, 280, 88 Hexadecimal Os números na base 16 devem ser precedidos de 0x. Ex.: 0x41, 0x1afb, 0x54c2 Octal Os números escritos na base 8 devem ser precedidos de um zero. Ex.: 041, 010, 0754. 2.4.2 Cadeia de Caracteres Constante A expressão “Primeiro Programa” é um exemplo de cadeia de caracteres constante. A linguagem C++reconhece uma cadeia de caracteres constante quando delimitada por aspas duplas. 2.4.3 O Qualificador const A palavra-chave const assegura que a variável associada não será alterada em todo o programa. Essequalificador é indicado para declarar valores constantes. Ex.: Const char bip=’a’; Const double pi=3.141592; As variáveis associadas ao qualificador const devem obrigatoriamente inicializadas. 28
  29. 29. 2.5 Operadores Aritméticos C++ é uma linguagem rica em operadores, em torno de 50. Alguns são mais usados que outros como é ocasodo operador de atribuição e os operadores aritméticos. 2.5.1 Operadores Aritméticos Básicos Tabela 10: Operadores aritméticos básicos em C++ Símbolo Operação + Adição - Subtração * Multiplicação / Divisão % Resto da divisão inteira - Multiplicação por –1 ex.: X = -5 2.5.2 Operadores de Incremento e Decremento Os operadores de incremento (++) e decremento (- -)são operadores unários que adicionam 1 e subtraem 1respectivamente. Estes operadores podem ser usados de duas formas: prefixado, quando aparece antes do nome da variável epósfixado, quando aparece depois da variável. As seguintes instruções são equivalentes: X = X + 1; // adiciona 1 a X ++X; // adiciona 1 a X X++; // adiciona 1 a X O mesmo é aplicável ao decremento: X = X – 1; // subtrai 1 de X - - X; // subtrai 1 de X X - -; // subtrai 1 de X A diferença entre o uso prefixado e pósfixado existe quando aparece em instruções que fazem mais do sóincrementar ou decrementar: N = 5; X = ++N; O resultado dessas operações é N=6 e X=6. N = 5; X = N++; O resultado é N=6 e X=5. 29
  30. 30. 2.5.3 Operadores Aritméticos de Atribuição Estes operadores binários combinam as operações aritméticas com atribuição. O operando da esquerda é umavariável e o da direita uma expressão. Como regra geral, se X é uma variável, exp uma expressão e op um operador aritmético, então: X op = exp equivale a X = X op (exp) Exemplos: Tabela 11: Exemplos dos operadores aritméticos de atribuição em C++ Operador Aritmético de Atribuição Expressão Equivalente A + = 2; A = A + 2; B * = Y + 1; B = B * (Y + 1); C / = 2.5; C = C / 2.5; Dado % = 5; D = D % 5; E - = 3; E = E - 3; 2.6 Operadores Relacionais Os operadores relacionais fazem comparações retornando verdadeiro ou falso. Tabela 12: Operadores relacionais em C++ Símbolo Operação > Maior < Menor >= Maior ou igual <= Menor ou igual == Igual != Diferente Em C++ não existe o tipo de variável chamada “booleana”. O valor zero (0) é falso e qualquer valor diferentede zero é verdadeiro. Assim toda expressão tem valor verdadeiro ou falso. Exemplo: int verdadeiro, falso; verdadeiro=(15<20); falso=(15 ==20); Os valores das variáveis serão: Verdadeiro = 1 Falso = 0 2.7 Operadores Lógicos Realizam operações booleanas. Devem ser utilizados com atenção, pois como foi mencionado toda expressãotem um valor verdadeiro ou falso, sendo que zero representa o falso e qualquer outro valor é verdadeiro. 30
  31. 31. Tabela 13: Operadores lógicos em C++ Símbolo Operação && E || Ou ! Não 2.8 Estrutura de um Programa A unidade fundamental de programas C++ são as funções. Um programa C++ consiste em uma ou váriasfunções. 2.8.1 Forma geral das funções C++ Os elementos básicos de toda função C++ são os seguintes: <tipo> <nome> (<parâmetros> ) { <instrução 1>; <instrução 2>; <instrução N>; } Onde: • Tipo: tipo de dado que a função retorna; • Nome: identificador da função; • Parâmetros: conjunto de parâmetros que a função necessita para realizar o seu processo; • Instruções: implementação da função; 2.8.2 O Primeiro Programa Vamos começar com um programa muito simples: #include <iostream.h> void main( ) { cout << “Primeiro Programa”; } Nome das Funções 31
  32. 32. Este programa compõe-se de uma única função chamada main. O nome de uma função pode ser qualquerum, com exceção de main, reservado para a função que inicia a execução do programa. Em todo programa C++, deve existir uma única função chamada main. A função main marca o ponto departida do programa. Se o programa for constituído de uma única função, esta será a main. O programa terminaquando for encerrada a execução da função main. O Tipo Void A função main particular de nosso programa é do tipo void. O tipo void indica que a função não tem valor deretorno, ou seja, não retorna nada. Chaves Toda função deve começar com uma chave de abertura de bloco { e deve terminar com uma chave defechamento de bloco }. As chaves delimitam o corpo da função. Instruções de Programa O nosso primeiro programa contém uma única instrução: Cout << “Primeiro Programa”; Essa instrução imprime a frase entre aspas duplas na tela. Toda instrução C++ termina em um ponto e vírgula (;). O ponto e vírgula é parte crucial da sintaxe dalinguagem. Uma função pode ter qualquer número de instruções. As instruções devem ser escritas entre aschaves que delimitam o corpo da função e são executadas na ordem em que as escrevemos. O Pré-processador C++ A primeira linha de nosso programa #include <iostream.h> não é uma instrução C++ e sim uma diretiva do pré-processador C++. O pré-processador C++ é um programa que examina o programa fonte em C++ executa nele certasmodificações com base em instruções chamadas diretivas. Toda diretiva é iniciada pelo # e seu texto deve serescrito em uma única linha. Se o texto for muito grande, pode-se terminar a linha com barra invertida “” econtinuar em outra linha. Diretivas do pré-processador não fazem parte da linguagem C++; elas servem para auxiliar odesenvolvimento do programa fonte. 32
  33. 33. A Diretiva #include A diretiva #include provoca a inclusão de outro arquivo em nosso programa fonte. Na verdade, o compiladorsubstitui a diretiva #include de nosso programa pelo conteúdo do arquivo indicado antes do programa sercompilado. Usar a diretiva #include é similar a usar o comando de um processador de textos que inclui um texto gravadoem disco no texto que estamos editando. A primeira linha de nosso programa #include <iostream.h> solicita que o compilador inclua o arquivo iostream.h em nosso programa antes de compilá-lo. Além do uso dos sinais < e > a diretiva #include aceita uma segunda sintaxe: #include “iostream.h” Quando usamos os sinais < e >, o arquivo é procurado somente no diretório include. Quando usamos aspas, oarquivo é procurado primeiramente no diretório atual e depois, se não for encontrado, no diretório include. Arquivos de Inclusão Os arquivos de inclusão (também chamados de arquivos de cabeçalho) são textos escritos em caracteresASCII normais. Em geral, eles contém definições e declarações necessárias para que o compilador reconheçavários identificadores da linguagem C++. É possível verificar o conteúdo desses arquivos utilizando um editor de texto ou comando type do DOS. Geralmente, os arquivos de inclusão têm um nome terminado com o sufixo “.H” ( de header ou cabeçalho) eestão gravados no diretório include. O Arquivo iostream.h O arquivo iostream.h é um exemplo de arquivo de inclusão. Ele contém declarações necessárias ao uso doobjeto cout e do operador de inserção <<. Sem essas declarações, o compilador não reconhece cout e <<. O arquivo iostream.h inclui ainda um objeto para recuperar dados digitados no teclado e também outrasdefinições básicas de entrada e saída necessária a todos os programas que fizerem uso da saída padrão (vídeo) eentrada padrão (teclado). 2.9 Comandos de Entrada e Saída 2.9.1 Imprimindo Usando cout 33
  34. 34. Cout (pronuncia-se “C out”) é um objeto de uma classe de I/O (entrada e sáida) predefinida em C++. C++ oferece uma biblioteca de funções e classes conhecida como “streams”. Elas contêm os elementosnecessários para a execução de operações de entrada e saída (I/O). O objeto cout está associado a uma saídapadrão (geralmente o vídeo). O operador <<, chamado de “operador de inserção”, conecta a mensagem a ser impressa à cout. As definições e declarações necessárias para o uso de “streams” estão contidas no arquivo “iostream.h”instalado no diretório include pelo compilador. Imprimindo Outros Tipos de Dados O próximo exemplo mostra como imprimir diferentes tipos de dados utilizando cout. #include <iostream.h> void main() { cout << “Vênus está a “ << 67 << “milhões de milhas” << ‘n’ << “dosol”; } Note que utilizamos o operador << repetidamente na instrução. Este uso é perfeitamente correto. O programaenvia primeiramente a cadeia “Vênus está a “ para cout, então envia o número 67, e em seguida a cadeia milhõesde milhas”, o caractere nova linha ‘n’ e finalmente a cadeia “do sol”. Executando o Primeiro Programa O nosso primeiro programa, quando executado, irá imprimir na tela: Primeiro Programa Se for executado três vezes seguidas, obteremos a seguinte saída: Primeiro ProgramaPrimeiro ProgramaPrimeiro Programa Note que o objeto cout não imprime numa nova linha automaticamente. A impressão é colocada na posiçãoatual do cursor. Se desejar caracter de nova linha, este deve ser impresso explicitamente. O caractere nova linha não pode ser inserido diretamente pelo teclado. Para inserir caracteres especiais éusada a seguinte tabela que será vista a seguir. Códigos Especiais 34
  35. 35. Além de enter, vários outros caracteres não podem ser inseridos diretamente pelo teclado. Esses caracteressão codificados em C++ por meio da combinação do sinal de barra invertida (barra invertida) com outroscaracteres. A seguir a tabela com esses códigos: Tabela 14: Códigos para caracteres especiais em C++ Códigos para Caracteres Especiais Significado n Nova linha (cr+lf) t Tab b Retrocesso f Salta página de formulário a Beep – toca o alto falante r CR – cursor para início da linha - barra invertida 0 Null – Zero ’ Aspa simples ” Aspa dupla x Representação hexadecimal Como fica o primeiro programa alterado para imprimir numa nova linha: #include <iostream.h> void main () { cout << “nPrimeiro Programa”; } 2.9.2 Lendo com cin e o Operador de Extração O objeto cin (pronuncia-se “C in”) manipula toda a entrada do teclado por meio do operador de extração >>que conecta a entrada de dados à variável que a conterá os dados. As definições necessárias ao uso de cin estãono arquivo iostream.h. Exemplo #include <iostream.h> void main () { cout << “nDigite a sua idade em anos: “; int anos; cin >> anos; cout << “nA sua idade em dias é: “ << (anos * 365); } o objeto cin aguarda até que seja pressionada a tecla enter para finalizar a entrada. O operador de extração >>toma o valor do objeto “streams” à sua esquerda e o coloca na variável à sua direita. 35
  36. 36. Múltiplas Entradas com cin: #include <iostream.h> void main () { cout << “nDigite as 4 notas: “; float p1,p2, p3, p4; cin >> p1 >> p2 >> p3 >> p4; float media=(p1+p2+p3+p4)/4; cout << “nmédia: “ << media; } Múltiplas entradas são digitadas separadas por um espaço em branco. O objeto cin entende um espaço comotérmino de uma entrada e o enter como finalizador geral. 2.10 Comentários Os comentários são utilizados para documentar o código fonte. É possível duas formas de comentário.Comentários delimitados por /* e */ podem ser escritos em várias linhas: Int D; /* um dos tipos de comentários em C++ permite o uso de múltiplas linhas. */ D = b * b – 4 * a * c; /* se Delta for negativo não existe raiz nos reais. Por isso o Delta deve ser testado antes do programa prosseguir */ Para comentários de uma única linha utiliza-se duas barras //, tudo que estiver a direita dessas barras éconsiderado comentário: // este comentário termina com o fim da linha X = X * 0.5; // Xis deve ser reduzido à metade 2.11 Desvio Condicional Os comandos de decisão permitem determinar qual é a ação a ser tomada com base no resultado de umaexpressão condicional. Veremos o comando de decisão if - else: If (<expressão de teste>) 36
  37. 37. <Instrução>; Para mais de uma instrução deve abrir um bloco de comandos: If (<expressão de teste>) { <Instrução 1>; <Instrução 2>; <Instrução N>; } Esta sintaxe é usada quando existe apenas comandos a serem executados quando a expressão de teste éverdadeira. Caso haja também comandos específicos a serem executados quando a expressão é falsa utiliza-se aseguinte sintaxe: If (<expressão de teste>) <Instrução>; Else <Instrução>; Para mais de uma instrução: If (<expressão de teste>) { <Instrução 1>; <Instrução 2>; <Instrução N>; } Else { <Instrução 1>; <Instrução 2>; <Instrução N>; } 2.12 Procedimentos e Funções A implementação de uma função segue a estrutura mencionada na parte de forma geral das funções, porémpara o seu uso pela main, a função deve ser definida antes da main: 37
  38. 38. #include <iostream.h> //definição da função int celsius (int fahr) { int c; c=(fahr –32)* 5/9; return c; } void main() { int c, f; cout << “nDigite a temperatura em Fahrenheit: “; cin >> f; c = celsius( f ); // chamada à função cout << “nCelsius = “ << c; } Pode-se definir a função após a main (ou da função que a utilizará) se ela for previamente prototipada. Oprotótipo consiste na somente declaração da função. 2.13 Classes A linguagem C++ é também conhecida como C com classes por incorporar os conceitos da orientação aoobjeto. A seguir a sintaxe para criação de classes: class <nome> { <variáveis privadas> <protótipo das funções privadas> public: <variáveis públicas> <protótipos das funções públicas> }; <implementação das funções> Veremos um exemplo de classe com herança: #include <iostream.h> 38
  39. 39. class animal { public: void comer(void); void dormir(void); void respirar(void);};class elefante : public animal { public: void trompete(void); void esguicho(void);};void animal :: comer (void) {cout << “Comendo...n”;}void animal :: dormir (void) {cout << “Dormindo...n”;}void animal :: respirando (void) {cout << “Respirando...n”;}void elefante :: trompete (void) {cout << “Trompete...n”;}void elefante :: esguicho (void) {cout << “Esguichando...n”;}void main (){ elefante Dumbo; Dumbo.respirar(); Dumbo.trompete(); Dumbo.dormir(); Dumbo.esguichar();} 39
  40. 40. Conclusão Através da elaboração deste trabalho foi possível definir alguns parâmetros no que se refere ao uso dessaslinguagens. A linguagem Pascal é uma linguagem procedural. Este tipo de linguagem está perdendo campo para aslinguagem orientadas ao objeto. Apesar disso, Pascal é a linguagem ideal para programadores iniciantes porapresentar comandos simples e de alto nível e também conceitos de fácil entendimento. Com ela é possível aonovato em desenvolvimento de sistemas exercitar lógica de programação, compreender o funcionamento dasestruturas de controle, que afinal estão presentes, mesmo que de formas diferentes, na maioria das linguagens deprogramação. Mesmo que o programador pretenda partir posteriormente para uma linguagem orientada aoobjeto, que é a tendência hoje em dia, é importante que se tenha uma base sólida sobre o uso e definição deprocedimentos e funções. Isso porque até mesmo as classes da orientação ao objeto utilizam operações que decerta forma se assemelham, em termos de programação, aos procedimentos e funções. Tal base pode ser obtidacom o exercício da programação em Pascal. A linguagem C++ possibilita a implementação da chamada orientação ao objeto. Apesar de ser evolução dalinguagem C, C++ ainda mantém a característica de ser uma linguagem de “médio nível”. Isto significa que C++tem características de uma linguagem de baixo nível, como a possibilidade de manipular diretamenteregistradores, mas vem acompanhado com arquivos, classes e objetos que permitem funções de alto nível, comoler do teclado e imprimir no vídeo. Mesmo que uma linguagem de médio nível que implementa orientação aoobjeto implique em mais poder e controle ao programador, não seria recomendável o uso de C++ para iniciantes,mas sim para programadores com alguma experiência e que compreendam o conceito da orientação ao objeto. 40
  41. 41. Referências Bibliográficas 1. MANZANO, José Augusto N. G.. Programando em Turbo Pascal 7.0. 6.ed. SãoPaulo: Érica, 1996. 2. MIZRAHI, Victorine Viviane. Treinamento em Linguagem C++ Módulo 1. São Paulo:Makron, 1994. 3. HOLZNER, Steven. Borland C++ Programação for Windows. São Paulo: Makron,1994. 41

×