Traduction du langage algorithmique vers C

Les éléments des langages sont écrits en gras

Les parties en italique doivent être remplacés par des éléments des langages

Langage algorithmique Langage C

Structure d'un programme
Algorithme Nom_Algo déclaration des types, des fonctions
TYPE et des constantes
déclaration des types et des fonctions void main()
CONST {
déclaration des constantes déclaration des variables/constantes
VAR instructions
déclaration des variables
début // commentaire
instructions autres_instructions
// commentaire /* autre commentaire
autres_instructions Sur plusieurs lignes */
/* autre commentaire }
Fin

Types de base
entier int
réel double, float
ajouter avant main :
#include <stdbool.h>
Booléen, Logique bool

caractère char
Déclaration des variables/constantes
void main()
variables : VAR identifiant :typebase { …. typebase identifiant ; ….}
(ex : x : entier) //exple : int x ;
void main()
constantes : CONST identifiant = valeur { ….const typebase identifiant =
valeur ; …}
//exple : const float Pi=3.14 ;

Ou bien
#define identifiant Valeur
void main(){ ….}
//exple : #define Pi 3.14
Opérateurs
affectation ← affectation =
arithmétiques + - * / mod div arithmétiques + - * / % /
int a,b; a/b;// division entière :DIV
float a; int b; a/b // division
réelle:/
logiques non et ou logiques : ! && ||
comparaison de nombres : comparaison de nombres :
= ≠ < <= > >= == != < <= > >=

conversion de type : entier -- > réel , réel -- conversion de type : int a=5,b=2 ;
>entier float S ;
S=(float)a/b, a=(int)S;
 Entrées-Sorties
ALGORITHME principal #include <stdio.h>
VAR void main()
a,b,s :entier
Debut { int a,b,s ;
écrire ("la somme de ",a, "et de ", b ," est ", a+b) printf("la somme %d et %d est
%d",a,b,a+b);
s ← a+b s = a+ b ;
écrire (a, " + ", b ," = ", s) printf("%d + %d = %d",a,b,s);

x,s :car char x,s ;

écrire ("le caractère est : ",x) printf("le caractère est:\t%c\n",x);
/*ou bien */
puts ("le caractère est:\t");
putchar(x);

écrire ("le code ascii de " , x ,"est printf("le code ascii de %c est :
",ORD(X)) %d",x,x);
s CHR(ORD(x)+1) s=x+1 ;
écrire ("le code ascii de " , x ,"est printf("le suivant de %c est :
",ORD(X)) %c\n",x,s);
}
FIN

int -> %d / float ->%f / double -> %lf

char -> %c
#include <stdio.h>
#include<conio.h>
ALGORITHME principal void main()
VAR {
a,c,d : entier int a ;scanf("%d",&a);
float c ; scanf("%f",&c);
lire (a) scanf("%f%d",&c,&a);
lire(c)
lire(c,a) char d; scanf("%c",&d);

lire(d) /*ou bien */ d=getchar();

/*ou bien */ d=getche();printf("\n");
FIN }
Fonctions prédéfinies
#include <math.h>
ALGORITHME principal void main(){
VAR int x=5,y=3,z;
x,y,z :entier
Debut
x ← 5, y ← 3
z=pow(x,y) ;
z← x^y
y ←sqrt(x) y=sqrt(x);
x ←abs(y) x=abs(y);
FIN }
ALGORITHME principal #include <ctype.h>
VAR D,d :car void main(){
Debut
d ← 'a' char D,d='a';
D ← Majus(d) D=toupper(d);
d ← Minus(d) d=tolower(d);
FIN }
 Conditionnelles
si (condition) if (condition)
alors {
instructions_1;
instructions_1 }
sinon else
instructions_2 {
instructions_2;
finsi
}
NB : le bloc sinon est optionnel
si (condition1) alors if (condition1)
instructions1 {
instructions1;
sinon si (condition2) alors }
instructions2 else if (condition2)
sinon {
instructions2;
instructions3
}
finsi else
finsi {
NB : le bloc sinon est optionnel instructions3;
}
Selon( variable ) Faire Switch(variable)
Valeur1 : instructions1 {
Valeur2 : instructions2 case Valeur1 : instruction1 ;break ;
Valeur3 : instructions3 case Valeur2 : instruction2 ;break ;
…. case Valeur3 : instruction3 ;break ;
ValeurN : instructions_N …
Sinon case ValeurN : instructionN ;break ;
instructionX default: instructionX;
Finselon }
Boucle pour
for (i=vi ; i<=vf ; i=i+p)//i+=p
pour i de vi à vf par pas=p faire
{
instructions
Instructions;
finpour
}
avec pas positif
for (i=vi ; i>=vf ; i=i-p)//i-=p
pour i de vi à vf par pas=-p faire
{
instructions
Instructions;
finpour
}
avec pas négatif
for (i=vi ; i<=vf ; i=i+1)//i+=1 ou
pour i de vi à vf faire i++
instructions {
finpour Instructions;
avec pas=1 }
for (i=vi ; i>=vf ; i=i-1)//i-=1 ou i-
pour i de vi à vf par pas=-1 faire -
instructions {
finpour Instructions;
avec pas=-1 }
 Boucle tant que
while (condition)
tantque (condition) faire
{
instructions
Instructions ;
fintantque
}
Boucle do … While

do
Repeter
{
instructions
Instructions ;
Jusqu’à(condition)
} while ( !condition) ;
Fonctions
fonction nom (paramètres) :Typebase typebase nom(paramètres)
VAR {
déclaration des variables
déclaration des variables ;
déclaration de la variable de retour
déclaration de la variable de
début
retour ;
instructions
instructions ;
nom  Valeur
return valeur ;
fin nom
}
procedure nom (paramètres) void nom(paramètres)
déclaration des variables {
début déclaration des variables ;
instructions instructions ;
fin nom }