Langage de programmation - Turbo C - Notes pour les programmeurs Turbo Pascal

Notes pour les programmeurs Turbo Pascal

Si vous étiez à l'origine un programmeur Turbo Pascal et que vous souhaitez faire le saut vers le Turbo C, vous devriez consulter cette page que vous ayez certain éclaircissement sur la changement que vous devrez tenir compte pour faire votre transition. En un mot, le Turbo Pascal est un langage assez discipliné et structuré, alors que le Turbo C est plutôt libre et flexible. Mais le Turbo C dispose aussi d'un système de mise en garde pour le programmeur ; il vous donne beaucoup d'informations pour vous orienter vers la direction que vous devez prendre. Le Turbo Pascal prend mieux soin de vous que le Turbo C, et est donc plus adapté comme langage de programmation pour apprendre les bases de la programmation. Le Turbo C et Turbo Pascal se déplacent vers le centre de ce spectre de langage C-Pascal : Le Turbo C ajoute une certaine structure au C, et le Turbo Pascal ajoute une certaine flexibilité à Pascal.

Structure du programme

Comme vous le savez, la structure du programme en Turbo Pascal prend la format suivante :

Program NomProgramme;
< déclarations
Const { ... }
Type { ... }
Var { librement mélangé }
procédures et fonctions >
BEGIN { Corps du programme NomProgramme, soit l'équivalent de main
< instruction >
END. { Fin du programme NomProgramme }

Le corps principal du programme est exécuté ; s'il appelle des procédures et des fonctions supplémentaires, elles sont également exécutées. Tous les identificateurs (constantes, types, variables, procédures et fonctions) doivent être déclarés avant d'être utilisés. Les procédures et fonctions sont organisées de manière quasi identique. La structure du programme en Turbo C est un peu plus flexible :

< Commandes de préprocesseur >
< définitions de type >
< prototypes de fonctions > /* librement mélangé */
< variables >
< fonctions >

Les fonctions, à leur tour, ont la structure suivante :

<type> NomFonction(<déclarations de paramètre>) {
<Déclarations local>
<Instructions>
}

De toutes les fonctions que vous déclarez, une doit être nommée main ; c'est le corps principal de votre programme. En d'autres termes, lorsque votre programme Turbo C commence à s'exécuter, main est appelé, et il peut à son tour appeler d'autres fonctions. Un programme Turbo C est entièrement constitué de fonctions. Cependant, certaines fonctions sont de type de données void, ce qui signifie qu'elles ne renvoient aucune valeur ; donc ils sont comme les procédures de Pascal. De plus (contrairement à Pascal), vous êtes libre d'ignorer toutes les valeurs renvoyées par une fonction. Le Turbo Pascal à partir de la version 6, permet d'ignorer le retour des fonctions, mais il ne respect pas le standard du Pascal.

Un exemple

Voici deux programmes, l'un écrit en Turbo Pascal, l'autre écrit en Turbo C, illustrant certaines des similitudes et des différences entre les deux dans la structure du programme :

Turbo Pascal	Turbo C
Program MonProg; Var I,J,K:Integer; Function Max(A,B:Integer):Integer;Begin If A > B Then Max := A Else Max := B; End; { Fin de la fonction Max } Procedure _Swap(Var A,B:Integer); Var Temp:Integer; Begin Temp:=A; A:=B; B:=Temp End; { Fin de la procédure Swap } BEGIN { Corps du programme MonProg } I:=10; J:=15; K:=Max(I,J); _Swap(I, K); Write('I = ',1:2,' J = ',J:2); Writeln(' K = ' ,K:2) END. { Fin du programme MonProg }	int i,j,k; int max(int a, int b) { if (a > b) return(a); else return(b); } /* Fin de la fonction max() / void* _swap(int a, int* b) { int* temp; temp = a; a = b; b = temp; } /* Fin de la fonction swap() / main() { i = 10; j = 15; k = max(i,j); _swap(&i,&k); printf("i = %2d j = %2d",i,j); printf(" k = %2d\n",k); } / Fin de la fonction main */

Turbo Pascal

Turbo C

Program MonProg;
Var I,J,K:Integer;
Function Max(A,B:Integer):Integer;Begin
If A > B Then Max := A
Else Max := B;
End;
{ Fin de la fonction Max }
Procedure _Swap(Var A,B:Integer);
Var
Temp:Integer;
Begin
Temp:=A; A:=B; B:=Temp
End;
{ Fin de la procédure Swap }
BEGIN { Corps du programme MonProg }
I:=10; J:=15;
K:=Max(I,J);
_Swap(I, K);
Write('I = ',1:2,' J = ',J:2);
Writeln(' K = ' ,K:2)
END.
{ Fin du programme MonProg }

int i,j,k;
int max(int a, int b) {
if (a > b) return(a);
else return(b);
}
/* Fin de la fonction max() */
void _swap(int *a, int *b) {
int temp;
temp = *a; *a = *b; *b = temp;
}
/* Fin de la fonction swap() */
main() {
i = 10; j = 15;
k = max(i,j);
_swap(&i,&k);
printf("i = %2d j = %2d",i,j);
printf(" k = %2d\n",k);
}
/* Fin de la fonction main */

Si nous avions choisi de le faire, nous aurions pu déclarer i, j et k à l'intérieur de main, plutôt que comme variables globales. Dans de nombreux cas, c'est une meilleure pratique de programmation, car cela élimine le risque (et la tentation) de modifier directement les variables globales dans les fonctions, tout en créant des variables existant tout au long du programme.

Une comparaison des éléments de programmation

Dans la page Plus de programmation dans Turbo C, nous avons parlé des sept éléments de base de la programmation - sortie, des types de données, des opérations, de l'entrée, de l'exécution conditionnelle, de l'exécution itérative et des sous-programmes. Examinons-les à nouveau, en voyant comment Turbo Pascal et Turbo C se ressemblent et diffèrent l'un de l'autre.

Sortie

Les principales commandes de sortie dans Turbo Pascal sont Write et WriteLn. Le Turbo C, d'autre part, a une variété de commandes, basées exactement sur ce que vous voulez faire. Le plus couramment utilisé, et celui demandant le plus de surcharge, est printf, prenant le format :

printf(format-string, item, item,...);

où format-string est une chaîne de caractères littérale ou une variable de chaîne de caractères (rappelez-vous, C utilise des guillemets doubles) et les item sont des variables facultatives, des expressions,..., correspondant aux commandes de format dans la chaîne de caractères de format. Pour obtenir une nouvelle ligne (= Writeln) en C, insérez la séquence d'échappement \n (nouvelle ligne) à la fin de la chaîne de format.

Turbo Pascal	Turbo C
Var A,B,C:Integer; Amt:Real; Name:String[20]; Ans:Char; Writeln('Bonjour'); Write('Qu''est-ce que vous dites ? '); WriteLn('"Bonjour," dit Sylvain'); Writeln(A,' + ',B,' = ',C); Writeln('Vous nous devez $' ,Amt:6:2); Writeln('Votre nom est ',Name,'?'); Writeln('Votre réponse est ',Ans); Write(' A = ',A:4); Writeln(' AA = " (AA) : 6);	int a,b,c; float amt; char name[21]; /* ou name / char ans; printf("Bonjour\n"); printf ("'Qu'est-ce que vous dites ? '"); printf("\"Bonjour,\" dit Sylvain\n"); printf("%d + %d = %d\n",a,b,c); printf("Vous nous devez $%6.2f\n",amt); printf("Votre nom est %s?\n",name) printf("Votre réponse est %c\n",ans); printf(" a = %4d",a); printf(" aa = %6d\n",aa);

Turbo Pascal

Turbo C

Var
A,B,C:Integer;
Amt:Real;
Name:String[20];
Ans:Char;
Writeln('Bonjour');
Write('Qu''est-ce que vous dites ? ');
WriteLn('"Bonjour," dit Sylvain');
Writeln(A,' + ',B,' = ',C);
Writeln('Vous nous devez $' ,Amt:6:2);
Writeln('Votre nom est ',Name,'?');
Writeln('Votre réponse est ',Ans);
Write(' A = ',A:4);
Writeln(' A*A = " (A*A) : 6);

int a,b,c;
float amt;
char name[21]; /* ou *name */
char ans;
printf("Bonjour\n");
printf ("'Qu'est-ce que vous dites ? '");
printf("\"Bonjour,\" dit Sylvain\n");
printf("%d + %d = %d\n",a,b,c);
printf("Vous nous devez $%6.2f\n",amt);
printf("Votre nom est %s?\n",name)
printf("Votre réponse est %c\n",ans);
printf(" a = %4d",a);
printf(" a*a = %6d\n",a*a);

Deux autres routines de sortie C que vous voudrez probablement connaître sont puts et putchar. La fonction puts prend une seule chaîne de caractères comme paramètre et l'écrit, en ajoutant automatiquement une nouvelle ligne. La fonction putchar est encore plus simple : il écrit un seul caractère. Ainsi, par exemple, les commandes suivantes sont équivalentes :

Turbo Pascal	Turbo C
WriteLn(Nom); Write('C''est un exemple !'); Writeln; Write(Caractere);	puts(Nom); puts("C'est un exemple !\n"); putchar(Caractere);

Types de données

La plupart des types de données Turbo Pascal ont des équivalents dans Turbo C. Le Turbo C a en fait une plus grande variété de types de données, avec différentes tailles d'entiers et de valeurs à virgule flottante, ainsi que les modificateurs signés et non signés. Voici un tableau donnant des équivalents approximatifs entre les types de données Turbo Pascal et Turbo C :

Turbo Pascal			Turbo C
Type	Taille	Intervalle	Type	Taille	Intervalle
Char	1 octet	chr(0 à 255)	char	1 octet	-128 à 127
Byte	1 octet	0 à 255	unsigned char	1 octet	0 à 255
Integer	2 octets	-32768 à 32767	short	2 octets	-32768 à -32767
			int	2 octets	-32768 à 32767
Word	2 octets	0 à 65535	unsigned int	2 octets	0 à 65535
LongInt	4 octets	-2³¹ à 2³¹-1	long	4 octets	-2³¹ à 2³¹-1
			unsigned long	4 octets	0 à 2³²-1
Real	6 octets	1E-38 à 1E+38	float	4 octets	± 3.4 E ±38
Double	8 octets	± 1.7 E ±308	double	8 octets	± 1.7 E ±308
Boolean	1 octet	False, True	La convention est 0 = false, non-zéro = true

Notez qu'il n'y a pas de type de données booléen en Turbo C ; les expressions nécessitant une valeur booléenne interprètent une valeur de zéro comme étant fausse et toute autre valeur comme étant vraie.

En plus des types de données répertoriés, le Turbo C prend en charge les types de données énumérés ; cependant, contrairement à Turbo Pascal, ce ne sont en fait que des constantes entières pré-assignées et sont complètement compatibles avec tous les types intégraux :

Turbo Pascal	Turbo C
Type Jours = (Dimanche,Lundi,Mardi,Mercredi,Jeudi,Vendredi,Samedi); var Aujourdhui:Jours;	enum jours = { Dimanche,Lundi,Mardi,Mercredi,Jeudi,Vendredi,Samedi }; enum jours aujourdhui;

Opérations

Le Turbo C a tous les opérateurs de Turbo Pascal, et plus encore. L'une des différences les plus fondamentales entre les deux langages de programmation est la manière dont l'affectation est gérée. En Pascal, l'affectation (:=) est une instruction. En C, l'affectation (=) est un opérateur pouvant être utilisé dans une expression.

Le tableau suivant montre une comparaison côte à côte des opérateurs dans Turbo Pascal et Turbo C. Ils sont répertoriés par ordre de priorité, les opérations regroupées ayant la même priorité :

Opération	Turbo Pascal	Turbo C
Moins unaire	A := -B;	a = -b;
Plus unaire	A := +B;	a = +b;
Négation logique	Not Flag	!flag
Complément au niveau du bit	A := Not B;	a = ~b;
Adresse	A := @B; ou A := Addr(B);	a = &b;
Référence de pointeur	A := Intptr^;	a = *intptr;
Taille de	A := SizeOf(B);	a = sizeof(b);
Incrémenter	Inc(A) et A:=Succ(A);	a++ et ++a
Décrémenter	Dec(A) A:=Pred(A);	a-- et --a
Multiplication	A := B * C;	a = b * C;
Division entière	A := B div C;	a = b / C;
Division de nombre réel (virgule flottante)	X := B / C;	x = b / C;
Modulo (restant d'une division)	A := B mod C;	a = b % C;
Addition	A := B + C;	a = b + C;
Soustraction	A := B - C;	a = b - C;
Décalage vers la droite	A := B shr C;	a = b >> C;
Décalage vers la gauche	A := B shl C;	a = b << C;
Supérieur à	A > B	a > b
Supérieur ou égale à	A >= B	a >= b
Inférieur à	A < B	a < b
Inférieur ou égale à	A <= B	a <= b
Égale à	A = B	a == b
Pas égale à	A <> B	a != b
Et binaire	A := B and C;	a = b & C;
Ou binaire	A := B or C;	a = b \| C;
Ou exclusif binaire	A := B xor C;	a = b ^ C;
Et logique	Flag1 and Flag2	flagl && flag2
Ou logique	Flag1 or Flag2	flagl \|\| flag2
Assignation	A := B; A := A op B;	a = b; a op = b;

Il existe des différences importantes dans les opérateurs C et la priorité des opérateurs.

Tout d'abord, les opérateurs d'incrémentation (++) et de décrémentation (--) peuvent être placés avant ou après le nom de la variable. Si l'opérateur est placé avant la variable, la variable est incrémentée (ou décrémentée) avant que le reste de l'expression ne soit évalué ; si après, l'expression est évaluée en premier, alors la variable est incrémentée (ou décrémentée). Deuxièmement, les opérateurs logiques en C (&&, ||) sont des opérateurs de court-circuit. Cela signifie que si le premier élément détermine la vérité de l'expression, alors le second n'est jamais évalué. Ainsi, contrairement à Turbo Pascal (nécessitant d'avoir la directive de compilation $B- d'activé), le C vous permet d'écrire ceci en toute sécurité :



while (i <= limit && list[i] != 0) /* ... */;

où limit est le plus grand index autorisé dans le tableau de liste. Si le premier élément (i <= limite) est faux, alors C sait que toute l'expression doit être fausse, et il n'évalue pas le deuxième élément (list[i] != 0), ce qui serait une erreur d'intervalle d'index. Troisièmement, le Turbo C permet de prendre l'expression générale :

A = A op B

où op est n'importe quel opérateur binaire (sauf pour && et ||) et remplacez-le par :

A op= B

Ainsi, par exemple, au lieu de A = A * B, vous pourriez écrire A *= B, et ainsi de suite. Cette possibilité est partiellement possible, uniquement avec les incrémentations ou les décrémentations, avec le Turbo Pascal version 4 ou plus avec les procédures Inc et Dec.

Entrée

Encore une fois, dans Turbo Pascal, vous avez une commande d'entrée de base, Read(...), avec quelques variantes (Readln(...), Read(f,...),...). Dans le Turbo C, la fonction principale utilisée pour la saisie au clavier est scanf, prenant le format suivant :

scanf(formatstring>, addr1, addr2,...);

où formatstring est une chaîne de caractères avec des indicateurs de format (comme dans printf), et chaque addr est une adresse dans laquelle scanf entrepose les données entrantes. Cela signifie que vous devrez souvent utiliser l'opérateur d'adresse de (&). Il existe également d'autres commandes couramment utilisées : gets, lisant une chaîne de caractères entière jusqu'à ce que vous appuyiez sur Enter; et getch, lisant un caractère directement depuis le clavier sans écho.

Voici quelques commandes d'entrée Turbo Pascal avec les commandes Turbo C correspondantes :

Turbo Pascal	Turbo C
ReadLn(A,B); ReadLn(Nom); ReadLn(X,A); ReadLn(C); Read(Kbd,C); { Jusqu'à Turbo Pascal 3 } c := ReadKey; { Turbo Pascal 4 à 7 }	scanf("%d %d",&a,&b); scanf("%s",nom); /* ou gets(nom); / scanf("%f %d",&x,&a); scanf("%c",c); c = getch(); c = getch*();

Soyez conscient d'une distinction importante entre ces deux façons de lire dans une chaîne de caractères (scanf et gets). La fonction scanf lit tous les caractères jusqu'à ce qu'un espace blanc (blancs, tabulations, nouvelle ligne) soit rencontré. En revanche, gets lira tout (y compris les blancs et les tabulations) jusqu'à ce que vous appuyiez sur Enter.

Déclaration de bloc

Le Turbo Pascal et Turbo C ont tous deux le concept d'une instruction de bloc (une collection d'instructions pouvant être placées partout où une seule instruction le peut). En Turbo Pascal, l'instruction de bloc prend le format :

BEGIN statement; statement; ... statement END;

En Turbo C, il prend ce format :

{ statement; statement; ... statement; }

Bien que le formulaire soit très similaire, il existe deux différences importantes :

En Turbo Pascal, vous n'avez pas besoin de mettre un point-virgule après la dernière statement dans un bloc ; en Turbo C, vous le faites.
En Turbo C, vous ne mettez jamais de point-virgule après l'accolade fermante ( } ) d'un bloc ; en Turbo Pascal, vous devrez peut-être le faire.

Exécution conditionnelle

Le Turbo Pascal et Turbo C prennent en charge deux constructions d'exécution conditionnelle : l'instruction if/then/else et l'instruction case. Le if/then/else est très similaire pour les deux :

IF expression-booleen
THEN statement
ELSE statement

if(expr)
statement;
else statement;

En Turbo Pascal et en Turbo C, la clause else est facultative et statement peut être remplacée par une instruction de bloc (comme déjà décrit). Il y a cependant quelques différences importantes.

En Turbo C, l'expr n'a pas besoin d'être booléen ; il doit juste se résoudre d'une manière ou d'une autre à une valeur nulle ou différente de zéro, où zéro est considéré comme faux et non nul est considéré comme vrai.
En Turbo C, l'expr doit être entre parenthèses.
En Turbo C, il n'y a pas alors.
En Turbo C, les points-virgules sont toujours requis après les instructions, à moins, bien sûr, que vous ayez une instruction de bloc à la place.

Dernière mise à jour : Mardi, le 18 janvier 2022

Section courante

A propos

Section administrative du site