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..........................................................................................................................8
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..................................................................................16

2
 1.11.1 Simples....................................................................................................................16
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......................................................................29
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ção
Para 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)

1.1.3 Debug

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

9
 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;
• 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.

10
 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;

Importante observar que Pascal não diferencia letras maiúsculas de minúsculas. Sendo as expressões abaixo o
nome da mesma variável:

11
 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;
Ap= ’Sistema Integrado de Cálculo de Geometria Espacial’;
Voltas=10;

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

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:

13
 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ó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 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
Const
Type
Var

14
 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);
Write(2);
Writeln(3);
Writeln;

15
 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}

1.11 Desvio Condicional

1.11.1 Simples

16
 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>;

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 desvio
condicional 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>;
<comando 2>;
<comando N>;
end;

17
 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

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ção
CRT Possui rotinas de geração de som, controle de vídeo e teclado.

18
 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 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;
• 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.

19
 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);

A passagem por valor permite que a procedure seja chamada diretamente com valores constantes ou com
variáveis, como abaixo:

Fatorial (10);

20
 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>;

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

21
 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>
<declaração da rotina N>

implementation
<rotina 1>
<rotina 2>
<rotina N>

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

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 é 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
 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 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 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 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 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)
Tanto X quanto Y terão valor 3. Este tipo de expressão é chamada atribuição múltipla.

27
 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çã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. 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.

2.5.3 Operadores Aritméticos de Atribuição

29
 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 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 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.
Tabela 13: Operadores lógicos em C++

30
 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

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.

31
 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

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

A Diretiva #include

32
 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

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

Cout (pronuncia-se “C out”) é um objeto de uma classe de I/O (entrada e sáida) predefinida em C++.

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

#include <iostream.h>
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

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:

34
 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ão
no 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.

Múltiplas Entradas com cin:

#include <iostream.h>

35
 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>)
<Instrução>;

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

36
 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 a
seguinte 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ém
para o seu uso pela main, a função deve ser definida antes da main:

#include <iostream.h>

//definição da função

37
 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:

#include <iostream.h>
class animal {
public:
void comer(void);

38
 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