Programacao de C++ para Pascal

Prévia do material em texto

1
 
Algoritmos e Estruturas de Dados II IBm1022 
Departamento de Computação e Matemática 2º Semestre/2012 
Prof. Dr. José Augusto Baranauskas Notas de Aula 
 
De C++ para Pascal 
 
O objetivo desta nota de aula consiste em mostrar como converter/escrever um programa em Pascal, 
conhecendo-se a linguagem C++. A linguagem, que recebeu este nome em homenagem ao matemático 
Blaise Pascal, foi criada em 1970 pelo suíço Niklaus Wirth. Pascal foi criada para ensinar programação 
estruturada. 
 
Na tabela seguinte é fornecida a correspondência entre a sintaxe C++ e Pascal. 
 
 C++ Pascal 
Declaração de 
variáveis 
int i; 
float r; 
char c; 
string s; 
bool b; 
var i : integer; 
 r : real; 
 c : char; 
 s : string; 
 b : boolean; 
Declaração de 
constantes 
const int max = 100, 
 float r = 10.0; 
const max = 100; 
 r = 10.0 
Registros struct cliente 
{ int numero; 
 char nome[30]; 
 float saldo; 
}; 
type cliente = record 
 numero : integer; 
 nome : string[30]; 
 saldo : real; 
 end; 
Atribuição <variável> = <expressão>; <variável> := <expressão>; 
Bloco { 
 <comando1>; 
 <comando2>; 
 ... 
} 
begin 
 <comando1>; 
 <comando2>; 
 ... 
end 
Repetição while(<condição>) 
 <comando>; 
while <condição> do 
 <comando>; 
 
do 
{ <comando1>; 
 <comando2>; 
} while(<condição>); 
repeat 
 <comando1>; 
 <comando2> 
until <condição>; 
 
for(i=1; i<=10; i++) 
 <comando>; 
for i := 1 to 10 do 
 <comando>; 
 
for(i=10; i>=1; i--) 
 <comando>; 
for i := 10 downto 1 do 
 <comando>; 
Seleção if(<condição>) 
 <comando>; 
if <condição) then 
 <comando>; 
 
if(<condição>) 
 <comando1>; 
else 
 <comando2>; 
if <condição) then 
 <comando1> 
else 
 <comando2>; 
 
switch (<variável>) 
{ case <constante1>: 
 <comando1>; 
 break; 
 case <constante2>: 
 <comando2>; 
 <comando3>; 
 break; 
 default: 
 <comando4>; 
} 
 
case <variável> of 
 <constante1>: 
 <comando1>; 
 <constante2>: 
 begin 
 <comando2>; 
 <comando3>; 
 end; 
 else 
 <comando4>; 
end; 
 
 2
 
A seguir é mostrado um exemplo de um programa C++ e seu correspondente em Pascal. 
C++ Pascal 
#include <iostream> 
using namespace std; 
int main() 
{ int i,i2; 
 
 cout << ”Numero? ”; 
 cin >> i; 
 i2 = i*i; 
 cout << ”Quadrado de ” << i 
 << ” = ” << i2 << endl; 
 return 0; 
} 
program teste; 
var i,i2 : integer; 
begin 
 write('Numero? '); 
 readln(i); 
 i2 := sqr(i); 
 writeln('Quadrado de ',i, 
 ' = ',i2); 
end. 
 
A seguir é fornecido outro exemplo. 
C++ Pascal 
#include <iostream> 
using namespace std; 
//------------------------------------ 
int fatorial(int n) 
{ int i,p; 
 
 p = 1; 
 for(i=2; i<=n; i++) 
 p = p * i; 
 return p; 
} 
 
//------------------------------------ 
void divide(int a, int b, int &resto) 
{ 
 resto = a % b; 
} 
 
//------------------------------------ 
int main() 
{ int x,y,r; 
 cout << "Entre dois numeros: "; 
 cin >> x >> y; 
 cout << "Fatorial de " << x << "=" 
 << fatorial(x) << endl; 
 divide(x,y,r); 
 cout << "Resto da divisao de " << x 
 << " por " << y << '=' << r 
 << endl; 
 return 0; 
} 
program teste2; 
 
//------------------------------------ 
function fatorial(n : integer): integer; 
var i,p : integer; 
begin 
 p := 1; 
 for i := 2 to n do 
 p := p * i; 
 fatorial := p; 
end; 
 
//------------------------------------ 
procedure divide(a,b:integer; var resto 
: integer); 
begin 
 resto := a mod b; 
end; 
//------------------------------------ 
var x,y,r : integer; 
begin 
 writeln('Entre dois numeros: '); 
 readln(x,y); 
 writeln('Fatorial de ',x,'=', 
 fatorial(x)); 
 divide(x,y,r); 
 writeln('Resto da divisao de ',x, 
 ' por ',y,'=',r); 
end. 
 
Como diferenças especiais entre Pascal e C++, podemos mencionar que: 
• Pascal não diferencia entre minúsculas e maiúsculas. Assim, por exemplo, X representa o mesmo 
que x; 
• O abrir/fechar chaves em C++, ou seja, {e } tem seus correspondentes em Pascal: begin e end 
• Todo comando em Pascal termina com um ponto-e-vírgula. Entretanto, o ponto-e-vírgula é opcional 
antes de um end 
• No caso do comando if-then-else, nunca utilize ponto-e-vírgula antes do else 
• Os correspondentes de cin e cout são input e output, respectivamente; entretanto, há uma 
diferença que a entrada padrão em Pascal (input) nunca é fechada. Dessa forma, não é possível 
testar por fim-de-arquivo, ou seja, não tem funcionalidade o fragmento de código: 
while not eof(input) do 
 3
... 
• No caso de strings, os comandos read/readln lêem até o final de linha (de forma similar ao 
getline em C++) 
• Em Pascal, parâmetros passados por referência (por variável) devem ser precedidos pela palavra 
reservada var; isso se aplica a todos os tipos de dados, incluindo tanto os tipos primitivos como os 
estruturados; observe que este comportamento é diferente da linguagem C++, pois caso um vetor 
seja passado por valor, uma cópia do vetor será passada e não o vetor original 
• O comando do-while em C++ difere do comando repeat-until em Pascal: enquanto o primeiro 
continua o laço enquanto a condição for verdadeira, o segundo continua enquanto a condição for 
falsa, ou seja, quando a condição se tornar verdadeira o laço termina. 
C++ Pascal 
i = 1; 
do 
{ cout << i << endl; 
 i++; 
}while (i <= 10); 
i := 1; 
repeat 
 writeln(i); 
 i := i + 1; 
until i > 10; 
 
• Comentários (evite a forma // se quiser compatibilidade com Turbo Pascal/Delphi) 
C++ Pascal 
/* comentário 
 em diversas 
 Linhas */ 
(* comentário 
 em diversas 
 Linhas *) 
/* comentário 
 em diversas 
 linhas 
*/ 
{ comentário 
 em diversas 
 linhas 
} 
// comentário até o final de linha // comentário até o final de linha 
 
• Operador de Atribuição 
C++ Pascal 
= := 
 
• Operadores Aritméticos 
 C++ Pascal 
Soma + + 
Subtração - - 
Multiplicação * * 
Divisão (inteira) / (depende dos operandos) div 
Divisão (real) / (depende dos operandos) / 
Resto da divisão inteira % mod 
 
• Operadores Relacionais: 
C++ Pascal 
< < 
> > 
<= <= 
>= >= 
== = 
!= <> 
 
• Operadores Lógicos: 
C++ Pascal 
&& and 
|| or 
! not 
• Ponteiros 
 C++ Pascal 
 4
O que é apontado pelo ponteiro p (*p) p^ 
 
p->nome p^.nome 
 
Tipos 
• primitivos: 
o padrões: Integer, Boolean, Char, Real (tipos escalares) 
o criados pelo programador (a..b) 
• estruturados: criados pelo programador a partir de estruturas padrões: Array, Record, Set, etc. 
 
Type <nome1> = <tipo 1>; 
 <nome2> = <tipo 2>; 
 
Tipos primitivos criados pelo programador (enumera os valores que uma variável pode assumir) 
 
Type cor = (verde, azul, branco); 
 sexo = (fem, masc); 
 dia = (seg, ter, qua, qui, sex, sab, dom); 
 
Funções padrões: 
 succ(qua) = qui pred(ter) = seg 
 ord(fem) = 0 ord('A') = 65 
 ord('0') = 48 
 
Definição interna do Pascal: Type Boolean = (False, True); 
var d: dia; 
begin 
 for d := ter to sab do 
 case d of 
 seg: write('segunda'); 
 ter: write('terça'); 
 ... 
 dom: write('domingo'); 
 end; 
end. 
 
var d: dia; 
begin 
 for d := ter to sab do 
 case ord(d) of 
 0: write('segunda'); 
 1: write('terça'); 
 ... 
 7: write('domingo'); 
 end; 
end. 
Obs: Write(a), Writeln(a), Read(a), Readln(a) => a tem que ser de tipo primitivo e padrão. 
 
 
Tipos Intervalo (Subrange) 
 
Subconjuntos de um tipo escalar (excetoReal) já existente. 
var x : 1..40; 
 y : verde..azul; 
 z: 'A'..'J'; 
 posint: 0..Maxint 
Para verificação dos tipos subrange, colocar a diretiva {$R+} no início do programa. Há vários tipos de 
inteiros e reais; verifique a documentação do seu compilador para tipos adicionais. 
 
Tipos Estruturados 
 
Em Pascal: String, Array, Record, Set e File 
 
• String: cadeia de caracteres 
 type nome = string[15]; 
 linha = string[80]; 
 var n : nome; 
 l : linha; 
 Operações: Delete, Insert, Str, Val, Copy, Concat, Lenght, Pos 
 
• Array: estrutura homogênea (assim como string) 
 5
 type a = array[ T1 ] of T2 
 onde: T1 é o índice do tipo escalar, exceto Real; 
 T2 é o tipo base, podendo ser qualquer tipo de dado 
 Ex.1) type b = array[-1..8] of integer; 
 var b1 : b; 
 
 -1 0 1 2 3 4 5 6 7 8 
b1 
 
 
 Ex.2) var a : array['B'..'Z'] of char; 
 a['X'] := 'A'; 
 
 Ex.3) type dia = (dom,seg,ter,qua,qui,sex,sab); 
 var a : array[seg..sex] of string[10]; 
 a[ter] := 'ABCD'; 
 
• Record: estrutura heterogênea - mistura diferentes tipos de dados numa única estrutura. 
 type nome = record 
 c1 : T1; 
 c2 : T2; 
 ... 
 end; 
 onde c1, c2, ... são nomes de campos e T1, T2, ... são tipos de dados. 
 
 Ex.1) type data = record 
 dia : 1..31; 
 mes : (jan, fev, mar, ..., dez); 
 ano : 1900..2100; 
 end; 
 var p1, p2 : record 
 nome : string[20]; 
 adm, nasc : data; 
 salario : real; 
 depto : (vendas, compras, pessoal); 
 end; 
 
 Para ter acesso aos campos de um registro: 
<nome da variável> . <nome do campo> 
 
 Ex.2) p1.nome := 'Maria'; 
 p1.salario := 800.00; 
 p1.depto := pessoal; 
 p1.nasc.dia := 27; 
 p1.nasc.mes := fev; 
 p1.nasc.ano := 1960; 
 
• Set: conjunto de elementos de um mesmo tipo (escalar exceto Real). Os elementos do conjunto não são 
ordenados e nem aparecem repetidos. O número máximo de elementos em um conjunto é de 256. 
 type T = set of T1; 
 
 Ex.1) type diasdomes = set of 1..31; 
 letras = set of 'A'..'Z'; 
 caracteres = set of char; 
 coresprimarias = set of (vermelho, verde, azul); 
 var d, d1 : diasdomes; 
 l : letras; 
 c, c1 : coresprimarias; 
 d := [20,2,13]; 
 l := ['C', 'D','E']; 
 l := ['C'..'E']; 
 6
 c := [vermelho]; 
 c1 := [ ]; 
 d1 := [1, 5..10, 18..22]; 
 d1 := d1 - d; 
 
 Operadores: 
* intersecção 
<> desigualdade 
+ união 
>= 2o. operando contido no 1o. 
- diferença 
<= 1o operando contido no 2o. 
= igualdade 
in pertinência 
 
 Ex.2) if 3 in d1 then 
 write('3 pertence a d1'); 
 
Entrada e Saída 
• Read(lista-de-variáveis); 
• Readln(lista-de-variáveis); 
• Read(arquivo, lista-de-variáveis); 
• Readln(arquivo, lista-de-variáveis); 
• Write(lista-de-variáveis-contantes-expressões); 
• Writeln(lista-de-variáveis-contantes-expressões); 
• Write(arquivo,lista-de-variáveis-contantes-expressões); 
• Writeln(arquivo,lista-de-variáveis-contantes-expressões); 
 
Formatos: 
Inteiros: Write(I:5); _ _ _ _ _ 
Reais: Write(R:9:4); _ _ _ _ . _ _ _ _ 
 
Arquivos em Pascal 
 
Em Pascal, pode-se trabalhar com dois tipos de arquivos: arquivos texto e arquivos “tipados” (não-texto). Por 
exemplo: 
 var f : file of <tipo>; 
 t : text; 
 
Um arquivo declarado como “file of <tipo>” consiste numa sequência linear de componentes do tipo <tipo>, 
que pode ser qualquer tipo de dado da linguagem Pascal, exceto um arquivo. 
 
O tipo “text” significa um arquivo contendo caracteres organizados em linhas. Geralmente é utilizado para 
entrada e saída de dados de forma simples. 
Ex: type empregado = record 
 nome : string[30]; 
 salario : longint; 
 dep : (vendas, compras, pessoal); 
 end; 
 var entrada : text; 
 emp : file of empregado; 
 
 
Manipulação de arquivos 
Onde estiver escrito: 
 var f, deve-se substituir por uma variável de arquivo qualquer; 
 var f : text, deve-se substituir por uma variável de arquivo text; 
 var f : file, deve-se substituir por uma variável de arquivo não-text; 
 7
 
• Assign(var f; nome : string); 
Atribui um nome externo de arquivo (do sistema operacional) a uma variável do tipo arquivo. 
• Reset(var f ); 
Abre um arquivo existente, posicionando o ponteiro do arquivo no início. 
• Rewrite(var f); 
Cria e abre um novo arquivo. 
• Append(var f : text); 
Abre um arquivo existente, posicionando o ponteiro do arquivo no final, permitindo adicionar linhas. 
• Close(var f); 
Fecha um arquivo. Todo arquivo utilizado por um programa deve ser fechado com esse comando. 
• FileSize(var f : file) : Longint; 
Retorna o tamanho atual de um arquivo. 
• FilePos(var f : file) : Longint; 
Retorna a posição atual do ponteiro do arquivo. 
• Seek(var f : file; n : Longint); 
Move o ponteiro de um arquivo para a nova posição especificada em <n>. O primeiro registro é o de 
número zero. 
• Eof(var f) 
End-of-file (fim-de-arquivo). Retorna TRUE se o ponteiro do arquivo esta no final de arquivo ou 
FALSE, caso contrário. 
 
Operações permitidas conforme o tipo do arquivo 
 
Arquivos text Arquivos não-text 
Assign Assign 
Reset Reset 
Rewrite Rewrite 
Append Close 
Close FileSize 
Eof FilePos 
 Seek 
 Eof