estruturação de linguagens de programação (pascal e c++)

UNIVERSIDADE LUTERANA DO BRASIL

CENTRO DE CIÊNCIAS EXATAS E NATURAIS

CURSO DE SISTEMAS DE INFORMAÇÃO

ESTRUTURAÇÃO DE LINGUAGENS (PASCAL E C++)

MAURICIO VOLKWEIS ASTIAZARA

Paradigmas de Linguagem de Programação

Torres, Agosto de 2001

Sumário

Lista de Tabelas.....................................................................................5

Resumo..................................................................................................6

Introdução..............................................................................................7

1 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

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..............................................................................................22

2 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

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......................................................................................................38

Conclusão............................................................................................40

Referências Bibliográficas..................................................................41

4

Lista de Tabelas

5

Resumo

Este trabalho mostra de forma superficial 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.

Abstract

This work show on surface form the basic concepts about two programming languages: Pascal and C++. The

approached topics are needed and basic for a programmer who unknow the language can to make a small

program and to understand main characteristcs from each language. Into presents itens there are data types from

each language and the way how each work with it.

6

IntroduçãoPara escolhermos um linguagem de programação precisamos de certos conhecimentos básicos sobre cada

uma, 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++, com

o objetivo de destacar as principais características e para que se tenha uma base mínima das possibilidades de

cada linguagem.

7

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 tarefas

operacionais. 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 dos

editores 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 nos

menus 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

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 Pascal

fornece 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 qualquer

nú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ênciaShortint De –128 até 127Integer De –32.768 a 32.767Longint De –2.147.483.648 até 2.147.483.647Byte De 0 até 255Word 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. Em

Pascal 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ênciaReal De 2,9 E-39 até 1,7 E+38Single De 1,5 E-45 até 3,4 E+38

9

Double De 5,0 E-324 até 1,7 E+308Extended De 3,4 E-4.932 até 1,1 E+4.932Comp 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 de

uma mantissa (parte fracionária). O tipo single usa uma mantissa de 7 a 8 dígitos, o tipo real usa uma mantissa de

11 dígitos, o tipo double usa uma mantissa de 15 a 16 dígitos e os tipos extended e comp utilizam um mantissa

de 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. Uma

seqüê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. Existe

ainda 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 tipo

somente 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 identificada

e que tem por finalidade armazenar informações (dados) de um programa temporariamente. Uma variável

armazena apenas um valor por vez. Sendo considerado como valor o conteúdo de uma variável, desta forma, um

valor 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, sendo

assim, é 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

• 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 saber

qual o seu tipo para depois fazer o seu armazenamento. Estando armazenado o dado este poderá ser utilizado e

manipulado 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, bem

como o seu tipo. Desta forma é efetuada uma reserva de memória para que as variáveis sejam utilizadas. A

declaraçã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. Como

esquematizado 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

Importante observar que Pascal não diferencia letras maiúsculas de minúsculas. Sendo as expressões abaixo o

nome 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 por

qualquer subrotina subordinada. Uma variável é local quando é declarada dentro de uma subrotina e é somente

vá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 um

sinal 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 ou

o 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 diretamente

mencionado 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 o

programa. Exemplo:

Const

PI= 3.141592;

12

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 é muito

usado e ao mesmo tempo tem grande extensão de caracteres (como o PI) ou é freqüentemente alterado para fins

de 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 realDiv Divisão inteiraMod 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 um

exemplo 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 que

indica uma afirmação. O resultado é a confirmação ou negação da expressão através de um valor booleano (visto

anteriormente). 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

Os operadores relacionais podem comparar valores numéricos (inteiros e reais) e caracteres (através do valor

do caracter na tabela ASCII). Por retornarem um valor booleano podem ser armazenados numa variável do tipo

boolean:

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, sendo

assim só operam com dados do tipo boolean. São os seguintes:

Tabela 5: Operadores lógicos em Pascal

Operador LógicaNot Retorna o oposto do valor. Este é o único operador unário.And Retorna Verdadeiro somente se todos os valores forem VerdadeirosOr Retorna Falso somente se todos os valores forem FalsosXor 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 de

variáveis. Não poderá haver variável com o mesmo nome do programa. O cabeçalho é atribuído pela instrução

program 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 esta

subdividida em sete subáreas:

Uses

Label

14

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 a

instrução begin e é finalizada com a instrução end seguida de ponto final (.). O uso dessas duas instrução

caracteriza 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 a

seguinte 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 nova

linha. 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

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 e

finalizados 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ção

e 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

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 a

instruçã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ção

verdadeira, 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>;


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 desvio

condicional composto executa um comando se o valor for verdadeiro e outro comando se o valor for falso.

Possui a seguinte sintaxe:


<comando para valor verdadeiro>

else

<comando para valor falso>;


begin

<comando 1>;

<comando 2>;

<comando N>;

end

else

begin

<comando 1>;

17

<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 determinado

trecho de instruções enquanto uma determina expressão for verdadeira (True). Uma das estruturas de laço

oferecidas 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 e

end. 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 um

valor inicial. A cada iteração acrescenta 1 a esta variável. O loop só termina quando a variável possuir valor

igual 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 Pascal

permite a construção de sub-rotinas de dois tipos: Procedures (procedimentos) e Function (função). A diferença

entre as duas é que a função retorna um valor.

1.13.1 Unidades Padrão

18

Além de permitir a construção de rotinas, existe ainda um conjunto de rotinas prontas, ou seja, oferecidas

pela Borland. Estas rotinas estão agrupadas em bibliotecas, chamadas units. O Turbo Pascal passou a incorporar

o conceito de units a partir da versão 4. A seguir as principais units:

Tabela 6: Principais unidades padrão em Pascal

Unit DescriçãoCRT 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ívelGRAPH Esta unidade possui rotinas destinadas à manipulação da capacidade

gráfica do computadorOVERLAY 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 por

ví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 de

comandos 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

• 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 procedimento

requerer, 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 de

execuçã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 que

armazenem estes valores. Esta declaração segue as mesmas regras da declaração de variáveis, o nome da

variá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 passado

para a variável que recebe o valor. A declaração de parâmetros por valor é feita da seguinte forma:

Procedure fatorial (n: integer);

20

A passagem por valor permite que a procedure seja chamada diretamente com valores constantes ou com

variá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 sejam

passado através de uma variável, não sendo permitido o uso direto de uma constante. Na passagem por referência

não é efetuada uma cópia do valor e sim do endereço de memória da variável. Isso faz com que qualquer

manipulação do valor do parâmetro dentro da procedure seja refletida na variável da rotina que chamou a

procedure, 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álidas

també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 é determinado

na 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 algum

momento do bloco de comandos (entre o begin e o end) deverá haver um comando de atribuição ao nome da

função:

<nome da função>:=<valor>;

21

Se mais de um retorno for dado à função em momentos diferentes somente o último prevalecerá. Apesar de

utilizar o comando de atribuição de forma semelhante à uma variável, não poderá ser feita a leitura da função

dentro dela mesma mesmo que um valor já tenha sido atribuído à ela. A tentativa de leitura do valor da função

dentro dela mesma caracteriza uma chamada recursiva, que se não tratada corretamente provocará um erro de

estouro 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 mesmo

trecho de código para sua solução. Isto pode ser facilitado com a construção de rotinas e funções para o

programa, mas muitas vezes esses problemas aparecem em programas diferentes. Pode-se copiar o código fonte

de um programa para outro, mas existe uma forma mais inteligente fornecida pelo Pascal. Consiste em juntar um

grupo 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, simplesmente

mencionando 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 um

novo arquivo, porém ao invés de program é utilizado a declaração unit. Logo após está a área interface. Nela

estão as declarações de todas as funções contidas na unit que são públicas, ou seja, utilizáveis pelo programador

que mencionar (através de uses) a unidade em seu programa. Na área implementation contém o código de todas

as rotinas mencionadas na parte de interface

Unit <nome>;

Interface

<declaração do rotina 1>

<declaração da rotina 2>

22

<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ão

podem ser diretamente executadas.

23

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 registro

campos que conterão dados e campos que conterão funções para operar os campos de dados do registro. Uma

unidade assim é definida como classe.

Uma classe é considerada um tipo de dado como os outros tipos que existem predefinidos em compiladores

de diversas linguagens de programação.

Como exemplo, considere o tipo int que é predefinido em C e C++. Podemos declarar quantas variáveis do

tipo int forem necessárias ao programa. De modo similar, podemos declarar quantas variáveis quisermos de uma

classe 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 cria

nenhuma 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 de

acesso 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 membro

que 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. Dizemos

entã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 que

funções interagiram com elas: são as funções-membro do objeto. Nenhuma outra função pode acessar esses

dados. 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 um

objeto”.

2.1.3 Herança

A programação orientada ao objeto oferece uma maneira de relacionar classes umas com as outras por meio

de hierarquias.

No nosso dia a dia, esse processo está presente quando dividimos classes em subclasses, mantendo o

princípio de que cada subclasse herda as características da classe da qual foi derivada. Por exemplo a classe de

24

animais é dividida nas subclasses mamíferos, aves, peixes, etc. uma das características da classe animais é a

reproduçã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:

Em programação orientada a objeto, o conceito de subclasse ou processo de classes derivadas é chamado

herança.

Em C++, a classe de origem é chamada classe base e as classes que compartilham as características de uma

classe 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 tarefas

tradicionais. Você escreve uma função quando identifica várias seções diferentes de um programa, em parte

executem a mesma coisa.

Em C++, você define uma classe-base quando identifica características comuns em um grupo de classes

derivadas.

Da mesma forma que você pode criar uma biblioteca de funções úteis a diversos programas, pode formar

uma 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 classe

base, é possível adicionar a ela características diferentes que a tornarão capaz de executarmos exatamente o que

desejarmos.

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ódigos

repetitivos. A uma função de biblioteca não podemos adicionar outras implementações a não ser que ela seja

reescrita 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 maiores

benefícios por linguagens orientadas ao objeto.

2.2 Tipos de Dados

25

CaracterísticasA B

CaracterísticasA B C D

CaracterísticasA B E F

CaracterísticasA B C F G

O tipo de uma variável informa a quantidade de memória, em bytes que a variável ocupará e a forma como o

valor será armazenado e interpretado.

Em C++, existem cinco tipos básicos de variáveis.

Tabela 7: Tipos de dados em C++

Tipo Bytes EscalaChar 1 -128 a 127Int 2 -32.768 a 32.767Float 4 3,4E-38 a 3,4E+38Double 8 1,7E-308 a 1,7E+308Void 0 Nenhum valor

Com exceção do tipo void, os tipos de dados básicos podem se acompanhados por modificadores na

declaraçã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 EscalaUnsigned char 1 0 a 255Unsigned 2 0 a 65.535Short 2 -32.768 a 32.767Long 4 -2.147.483.648 a 2.147.483.647Unsigned long 4 0 a 4.294.967.295Long 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 bits

de 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 um

nome para referenciar o seu conteúdo.

O espaço de memória ocupado por uma variável pode ser compartilhado por diferentes valores segundos

certas 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

• 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 seu

conteúdo.

Em C++ todas as variáveis devem ser declaradas. As variáveis devem ser declaradas antes de serem usadas

no 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 por

ví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 ser

escrita

Y=(X=3)

27

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 um

valor 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 por

identificadores 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çãoDecimal Escrevemos um número em decimal de forma pura e simples, como aquela que

estamos acostumados. Ex.: 20, 280, 88Hexadecimal Os números na base 16 devem ser precedidos de 0x. Ex.: 0x41, 0x1afb, 0x54c2Octal 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. Esse

qualificador é 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

2.5 Operadores Aritméticos

C++ é uma linguagem rica em operadores, em torno de 50. Alguns são mais usados que outros como é ocaso

do 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 1

respectivamente.

Estes operadores podem ser usados de duas formas: prefixado, quando aparece antes do nome da variável e

pó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

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 é uma

variá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 EquivalenteA + = 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 diferente

de 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ão

tem um valor verdadeiro ou falso, sendo que zero representa o falso e qualquer outro valor é verdadeiro.

30

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árias

funçõ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

Este programa compõe-se de uma única função chamada main. O nome de uma função pode ser qualquer

um, 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 de

partida do programa. Se o programa for constituído de uma única função, esta será a main. O programa termina

quando 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 de

retorno, 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 de

fechamento 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 da

linguagem. Uma função pode ter qualquer número de instruções. As instruções devem ser escritas entre as

chaves 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


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 certas

modificações com base em instruções chamadas diretivas. Toda diretiva é iniciada pelo # e seu texto deve ser

escrito em uma única linha. Se o texto for muito grande, pode-se terminar a linha com barra invertida “\” e

continuar em outra linha.

Diretivas do pré-processador não fazem parte da linguagem C++; elas servem para auxiliar o

desenvolvimento do programa fonte.

32

A Diretiva #include

A diretiva #include provoca a inclusão de outro arquivo em nosso programa fonte. Na verdade, o compilador

substitui a diretiva #include de nosso programa pelo conteúdo do arquivo indicado antes do programa ser

compilado.

Usar a diretiva #include é similar a usar o comando de um processador de textos que inclui um texto gravado

em disco no texto que estamos editando.

A primeira linha de nosso programa


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, o

arquivo é 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 caracteres

ASCII normais. Em geral, eles contém definições e declarações necessárias para que o compilador reconheça

vá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) e

estã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 do

objeto 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 outras

definições básicas de entrada e saída necessária a todos os programas que fizerem uso da saída padrão (vídeo) e

entrada padrão (teclado).

2.9 Comandos de Entrada e Saída

2.9.1 Imprimindo Usando cout

33

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 elementos

necessários para a execução de operações de entrada e saída (I/O). O objeto cout está associado a uma saída

padrã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.


void main()

{

cout << “Vênus está a “ << 67 << “milhões de milhas” << ‘\n’ << “do

sol”;

}

Note que utilizamos o operador << repetidamente na instrução. Este uso é perfeitamente correto. O programa

envia primeiramente a cadeia “Vênus está a “ para cout, então envia o número 67, e em seguida a cadeia milhões

de 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ção

atual 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

Além de enter, vários outros caracteres não podem ser inseridos diretamente pelo teclado. Esses caracteres

são codificados em C++ por meio da combinação do sinal de barra invertida \ (barra invertida) com outros

caracteres. 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:


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ão

no arquivo iostream.h. Exemplo


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

Múltiplas Entradas com cin:


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 como

té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 uma

expressão condicional. Veremos o comando de decisão if - else:

If (<expressão de teste>)

36

<Instrução>;

Para mais de uma instrução deve abrir um bloco de comandos:


{

<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 a

seguinte sintaxe:


<Instrução>;

Else

<Instrução>;

Para mais de uma instrução:


{

<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ém

para o seu uso pela main, a função deve ser definida antes da main:

37


//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. O

protó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 ao

objeto. 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:


38

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

Conclusão

Através da elaboração deste trabalho foi possível definir alguns parâmetros no que se refere ao uso dessas

linguagens.

A linguagem Pascal é uma linguagem procedural. Este tipo de linguagem está perdendo campo para as

linguagem orientadas ao objeto. Apesar disso, Pascal é a linguagem ideal para programadores iniciantes por

apresentar comandos simples e de alto nível e também conceitos de fácil entendimento. Com ela é possível ao

novato em desenvolvimento de sistemas exercitar lógica de programação, compreender o funcionamento das

estruturas de controle, que afinal estão presentes, mesmo que de formas diferentes, na maioria das linguagens de

programação. Mesmo que o programador pretenda partir posteriormente para uma linguagem orientada ao

objeto, que é a tendência hoje em dia, é importante que se tenha uma base sólida sobre o uso e definição de

procedimentos e funções. Isso porque até mesmo as classes da orientação ao objeto utilizam operações que de

certa forma se assemelham, em termos de programação, aos procedimentos e funções. Tal base pode ser obtida

com 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 da

linguagem 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 diretamente

registradores, mas vem acompanhado com arquivos, classes e objetos que permitem funções de alto nível, como

ler do teclado e imprimir no vídeo. Mesmo que uma linguagem de médio nível que implementa orientação ao

objeto 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

Referências Bibliográficas

1. MANZANO, José Augusto N. G.. Programando em Turbo Pascal 7.0 . 6.ed. São

Paulo: É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

estruturação de linguagens de programação (pascal e c++)

Technology