-----------------------
Definizionde di blocco: begin equivale a { ed end equivale a }.
begin -> {
. .
. .
end; -> }
-----------------------
I Tipi di dato
Da definirsi a inizio procedura come in pascal, ma dentro il blocco:
var a:integer;
b:char;
begin
...
end.
Diventa:
{
int a;
char b;
...
}
-----------------------
INTERI
byte -> unsigned char
word -> unsigned short int
integer -> int
longint -> long int
Possono essere marcati unsigned anche i long int.
-----------------------
REALI
real -> nessuna corrispondenza
single -> float
double -> double
extended-> nessuna corrispondenza
comp -> nessuna corrispondenza
-----------------------
CARATTERE
char -> char
string -> nessuna corrispondenza in C. In java esiste il tipo String.
Le stringhe in C sono gestite come array di caratteri, mentre in Java sono
degli oggetti particolari di tipo String.
-----------------------
ARRAY
var a:array [0..1000] of char; -> char a[1000];
N.B. Gli array hanno sempre, come primo elemento, lo 0.
-----------------------
RECORD
record a
....
end;
Diventa:
struct a {
...
};
-----------------------
PUNTATORI
var p:^int -> int *p;
Se la dimensione del tipo di variabile e' definita (come in questo caso)
non occorre ulteriore allocazione di memoria.
In Java i puntatori non esistono.
-----------------------
STRINGHE
Gestite come array di caratteri:
var a:string[10] -> char a[10];
In caso di utilizzo di puntatori e' necessario allocare memoria.
Se si utilizzano i puntatori non e' necessario specificare la dimensione della
stringa (che termina con un carattere nullo). Incrementando il puntatore (di
tipo char, ovviamente) si scorre la stringa.
-----------------------
TIPI PARTICOLARI.
Void: tipo "vuoto" (tutto deve avere un tipo in C, quando non serve si
utilizza void).
-----------------------
FUNZIONI
Non c'e' distinzione fra procedure e funzioni; la struttura e' simile a
quella delle funzioni in pascal:
procedure pippo (a:integer);
begin
...
end;
diventa
void pippo (int a)
{
...
}
Per le funzioni, ovviamente, al posto di void si utilizzera' il tipo di
dato che si vuol ritornare (restituire):
function pippo:integer;
begin
...
pippo=xxx;
end;
diventa
int pippo(void)
{
...
return (xxx);
}
-----------------------
Il blocco principale del programma non e' automaticamente quello che inizia
senza una dichiarazione di procedura o funzione come in pascal, ma una
particolare funzione da chiamarsi main:
program pippo;
procedure xxx;
begin
...
end;
begin
...
end.
diventa
void xxx(void)
{
...
}
main()
{
...
}
----------------------
OPERATORI
+ -> +
- -> -
* -> *
/ -> /
mod -> %
:= -> =
and -> &&
or -> ||
xor -> ^
shl -> <<
shr -> >>
Inoltre sono disponibili queste abbreviazioni:
x:=x+1 -> x++
x:=x-1 -> x--
x:=x+n -> x+=n
x:=x-n -> x-=n
x:=x/n -> x/=n
Gli operatori logici sono invece:
> -> >
< -> <
>= -> >=
<= -> <=
<> -> !=
= -> ==
and -> &&
or -> ||
not -> !
----------------------
Puntatori:
^ -> *
addr(x) -> &x
----------------------
STRUTTURE TIPICHE DI PROGRAMMAZIONE
Cicli for:
for c:=1 to 100 do
begin
...
end;
for (c=1; c<=100; c++)
{
...
}
In pratica l'istruzione for vuole tre parametri separati da punto e virgola:
1) Uno di assegnazione (in questo caso c=1);
2) Uno di controllo (in questo caso c<100);
3) Uno di operazione, separati da virgole (in questo caso c++, che e' un
modo abbreviato di scrivere c=c+1, come visto sopra)
----------------------
Cicli repeat e while
repeat
...codice...
until espressione;
In C diventa:
do {
...codice...
while (!espressione);
Il while ( cond ) do
begin
........
end
in C diventa :
while (condizione)
{
..
}
----------------------
IF
L'if e' molto simile:
if (a=b) and (c=d) then begin ... end
else begin ... end;
diventa
if (a==b && c==d) { ... }
else { ... }
----------------------
Anche l'istruzione CASE e' simile:
case a of
1:begin ... end;
2:begin ... end;
end;
diventa
switch (a) {
case 1: ...; ...; ...; break;
case 2: ...; ...; ...; break;
}
----------------------