MikroC

2021/2020
Faculté des Sciences - Kénitra - Université Ibn Tofail Classe : L3.P mécatronique

STRUCTURE D’UN PROGRAMME C : Type bit

Un programme C comporte une série d'instructions structurées en > Le type bit occupe un bit en mémoire.
blocs. Il peut y avoir une ou plusieurs fonctions dans un fichier. Nous pouvons déposer dans cette variable un 0 ou un 1 logique.
Cependant un fichier C contiendra toujours une fonction appelée
fonction principale, elle correspond à l'algorithme principal et peut Type entier non signé (entier naturel)
utiliser les autres fonctions définies dans ce fichier ou les fonctions > Le type char occupe un octet en mémoire.
prédéfinies du langage. Nous pouvons déposer dans cette variable un nombre entre 0 et
La fonction principale : 255.
> Le type int occupe deux octets en mémoire.
void main() { Nous pouvons déposer dans cette variable un nombre entre 0 et
…………………………… 65535.
}
Type entier signé (entier relatif)
> Le type signed char occupe un octet en mémoire.
Nous pouvons déposer dans cette variable un nombre
Les variables : entre -128 et +127.
L’essentiel du travail effectué par un programme d’ordinateur > Le type signed int occupe deux octets en mémoire.
consiste à manipuler des données. Ces données peuvent être très Nous pouvons déposer dans cette variable un nombre entre -
diverses, mais dans la mémoire de l’ordinateur elles se ramènent 32768 et 32767.
toujours en définitive à une suite finie de nombres binaires.
Pour pouvoir accéder aux données, le programme (quel que soit le
langage dans lequel il est écrit) fait usage d’un grand nombre de
LES DIFFERENTS TYPES DE BOUCLES :
variables de différents types. Le langage C fournit trois instructions pour réaliser des boucles :
- while
Une VARIABLE possède : - do …while
Un nom : Un variable apparaît en programmation sous un nom de - for
variable. 1-Tant que (condition) faire...
Un type : Pour distinguer les uns des autres les divers contenus while (condition) {
possibles, on utilise différents types de variables (entiers, réels, instructions;
chaîne de caractères …). }
Une valeur : Une fois la variable définie, une valeur lui est
assignée, ou affectée. Tant que la valeur de la condition est différente de zéro (faux), le
Une adresse : C’est l’emplacement dans la mémoire de l’ordinateur, contenu de la boucle est exécuté. Attention ! Etant donné que la
où est stockée la valeur de la variable. condition est testée en début de boucle, il est donc possible de ne
jamais entrer dans le corps de la boucle.
LES TYPES DE VARIABLES EN C : 2-Faire ... tant que (condition)
En langage C, comme dans d’autres langages, il faut toujours, par des do {
instructions précises, déclarer (définir) le nom et le type d’une instructions;
variable, avant de pouvoir lui affecter (assigner) une valeur (un } while (condition);
contenu) qui doit être compatible avec le type déclaré. Si par la suite
une autre valeur est affectée à une variable, la précédente est La condition est testée à la fin de la boucle, donc avec une boucle
perdue. do...while, on
passe toujours au moins une fois dans le corps de la boucle.
En mikroC les types de variables sont les suivants :
3-Boucle for
for(expression1;expression2;expression3){
instructions;
Size in

}
Range
bytes
Type

expression1 réalise des initialisations avant l'entrée dans la

bit 1–bit 0 or 1
boucle, expression2 est le test de continuation de boucle (test
(unsigned) char 1 0 .. 255 réalisé avant chaque itération), expression3 est évaluée à la fin
signed char 1 - 128 .. 127 de chaque itération.
(signed) int 2 -32768 .. 32767
C'est l'équivalent de :
unsigned (int) 2 0 .. 65535
(signed) long (int) 4 -2147483648 .. expression1;
2147483647 while(expression2)
{
unsigned long (int) 4 0 .. 4294967295 instructions;
float 4 -1.5 * 1045 .. +3.4 * 1038 expression3;
double 4 -1.5 * 1045 .. +3.4 * 1038 }
long double 4 -1.5 * 1045 .. +3.4 * 1038

1
 MikroC
2021/2020
Faculté des Sciences - Kénitra - Université Ibn Tofail Classe : L3.P mécatronique

Les expressions : A " + " Addition :

Les expressions en C vont nous permettre de réaliser des Effectue Ia somme aIgébrique des opérandes.
opérations entre plusieurs entités. Une expression est composée ExempIe : a = b + 3; // a contient Ia somme
d'un opérateur1 et de un ou pIusieurs opérandes2. de b et de 3
Nous aIIons distinguer 5 types d'expressions :
- I / Ies affectations; A " - " Soustraction :
- II / Ies opérations unaires; Effectue Ia différence des opérandes.
- III / Ies opérateurs binaires ExempIe a = b - 3; // a contient Ia différence de b et de 3
- IV / Ies auto-affectations;
- V / Ies comparaisons. A " * " Multiplication :
I l Les affectations Effectue Ie produit des opérandes.
ExempIe a = b * 3; // a contient 3 fois Ia vaIeur de b
A " = " Affectation :
PIace Ia vaIeur du 2e opérande dans Ie 1er. A " l " Division :
Le premier opérande ne peut pas être une constante. ExempIe Effectue Ie quotient des opérandes.
a = 5; // pIace Ia vaIeur 5 dans a ExempIe a = b / 3; // a contient Ie tiers de b
En généraI, si a est un entier, ( 3 * a ) ne redonnera pas b.

II l Les opérations unaires A " % " Modulo :

Renvoie Ie reste de Ia division entière des opérandes.
EIIes n'admettent qu'un seuI opérande. ExempIe a = 7 % 3; // a = 7 - ( 3 * 2 ) soit 1

A " . " Sélection d'un bit (Ie point) : A " && " ET logique :
Fait référence à un bit de I'opérande. Renvoie vrai si Ies 2 opérandes sont vrais et faux dans Ies 3
ExempIe : PORTA.2 = 1; // met RA2 à 1 autres cas. ExempIe if (a && b) c=1; // c=1 si a et b
sont vrais sinon c=0
A " - " Négation : // I'instruction if sera abordée pIus Ioin
Change Ie signe de I'opérande. ExempIe : a = 10;
b = - a; // b = - 10 A "&" ET binaire :
Effectue un ET Iogique bit à bit entre Ies opérandes.
A " ! " Complémentation logique : ExempIe a = 5; // a = 0000 0101
CompIémente une variabIe de type bit. ExempIe : bit a,b; b = 6; // b = 0000 0110
a = 1; c = a & b; // c = 0000 0100 soit c = 4
b = !a; // b = 0 A " || " OU logique :
Renvoie "1" si 1 ou 2 opérandes sont vrais et "0" dans I'autre
A " ~ " Complémentation à un : cas. ExempIe if (a || b) c=1; // c = 1 si a ou b sont
Inverse tous Ies bits de I'opérande. ExempIe : char a, b ; non nuIs , sinon c = 0
a = 5; // a = 0000 0101 soit 5 // I'instruction if sera abordée pIus Ioin
b = ~a; // b = 1111 1010 soit 255 – 5
A " | " OU binaire :
Effectue un OU Iogique bit à bit entre Ies opérandes.
ExempIe a = 5; // a = 0000 0101
1 SymboIe représentant une opération. Ex: =, + … b = 6; // b = 0000 0110
2 Entité sur IaqueIIe porte I'opération. Cette entité peut être fausse si c = a | b; // c = 0000 0111 soit c = 7
eIIe est égaIe à 0, vraie dans Ies autres cas.
A " ^ " OU exclusif binaire :
" ++ " Incrémentation : Effectue un OU excIusif bit à bit entre Ies opérandes.
Ajoute 1 à I'opérande. ExempIes : a = 14; ExempIe : a = 5; // a = 0000 0101
a++; // après exécution a=15 b = 6; // b = 0000 0110
c = ++a; // pré-incrémentation : a = (a+1) puis c = a c = a ^ b; // c = 0000 0011 soit c = 3
// après exécution c = 16
d = b++; // post-incrémentation : d = b puis b = (b+1) A " << " Décalage de bits à gauche :
DécaIe vers Ia gauche tous Ies bits du 1er opérande. Le
A " -- " Décrémentation : nombre de décaIages est donné par Ie 2e opérande.
Retranche 1 à I'opérande. ExempIes : a = 14; ExempIe : a = 11; // a = 0000 1011 soit a = 0xb
a--; b = a << 3; // b = 0101 1000 soit b = 0x58
a = --a; // pré-décrémentation : a = (a-1) puis c = a
// après exécution c = 12 A " >> " Décalage de bits à droite :
DécaIe vers Ia droite tous Ies bits du 1er opérande. Le
III l Les opérations binaires. nombre de décaIages est donné par Ie 2e opérande.
ExempIe a = 11 ; // a = 0000 1011
EIIes admettent pIusieurs opérandes. b = a >> 3 ; // b = 0000 0001 soit b = 1

2
 MikroC
2021/2020
Faculté des Sciences - Kénitra - Université Ibn Tofail Classe : L3.P mécatronique

IV l Les auto affectations

C'est une écriture condensée Iiée à une opération binaire et une En C, I'aIternative simpIe s'écrit comme suit :
affectation. Si I'on écrit a = a + b ; I'écriture de "a" intervient 2 If (condition) action;
fois, ce qui est inutiIe. Dans Ie cas de pIusieurs actions à réaIiser :
On pourra écrire : a += b ; // d'abord a+b , ensuite a = (a+b) If (condition) { action1; action2; …}
En C, I'aIternative compIète s'écrit comme suit :
ExempIes a += 1; // a = a + 1 Affectation- If (condition) action1; else action2;
somme Dans Ie cas de pIusieurs actions à réaIiser
b -= 2; // b = b - 2 Affectation-différence If (condition) {action1; action2; ...} else {actiona; actionb; ...}
c *= 3; // c = c * 2 Affectation-produit
d /= 4; // d = d / 4 Affectation/division La condition peut être une succession de conditions simpIes. Si Ia
e %= 5; // e = e % 5 Affectation-moduIo condition est trop compIiqué un message vous avertira.
f &= 6; // f = f & 6 Affectation-et ex : if (a==3 && b==5) c=2;
g |= 7; // g = g | 7 Affectation-ou
h ^= 8; // h = h ^ 8 Affectation-ou excIusif
i <<= 9; // i = i << 9 Affectation-décaIage à
gauche
j >>= 10; // j = j >> 10 Affectation-décaIage à
droite

V l Les comparaisons

A " = = " Egalité :

Renvoie vrai si Ies opérandes sont égaux et faux s'iIs sont
différents. ExempIe if( a == 2 ) b=1; // b vaut 1 si a =
2
// I'instruction if sera abordée pIus Ioin

A " ! = " Non égalité :

Renvoie vrai si Ies opérandes sont différents et faux s'iIs sont
égaux. ExempIe if( a != 2 ) b=0; // b vaut 0 si a différent de
2
// I'instruction if sera abordée pIus Ioin

A " > " Plus grand que :

Renvoie vrai si Ie 1er opérande est supérieur au 2e sinon faux.
ExempIe a = ( 10 > 20 ); // a = 0

A " < " Plus petit que :

Renvoie vrai si Ie 1er opérande est inférieur au 2e sinon faux.
ExempIe a = ( 10 < 20 ); // a = 1

A " >= " Plus grand que ou égal à :

Renvoie vrai si Ie 1er opérande est supérieur ou égaI au 2e sinon
faux. ExempIe if( b >= 2 ) a=1; // a vaut 1 si b est
supérieur ou égaI à 2
// I'instruction if sera abordée pIus Ioin

A " <= " Plus petit que ou égal à :

Renvoie vrai si Ie 1er opérande est inférieur ou égaI au 2e sinon
faux. ExempIe if( a <= 2 ) b=1; // b vaut 1 si a est
inférieur ou égaI à 2
// I'instruction if sera abordée pIus Ioin

L'alternative simple et complète (le if)

L'aIternative permet de faire un choix de réalisation d'action. II

existe deux types d'aIternatives. Alternative simple : si Ia
condition est vraie, aIors faire une action.
AIternative compIète : si Ia condition est vraie, aIors faire une
action sinon faire une autre action. A Ia fin de Ia réaIisation de
I'aIternative, Ia suite du programme s'exécute.