-
Les opérateurs arythmétiques
Tout d'abord les quatre opérations bien connues :
-
L'addition : le signe '+'
il est donc possible dans le programme C
suivant ( test_plus.c ) de faire :
#include
int main()
{
int a = 3;
int b = 7;
int c = 0;
printf("a=%d | b=%d |c=%d\n", a, b, c );
c = a+b;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 10 ( 3+7 )
a = a+c;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 13 ( 10+3 )
b= 3+50;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 53 ( 3+50 )
return(1);
}
-
La soustraction : le signe '-'
il est donc possible dans le programme C
suivant ( test_moins.c ) de faire :
#include
int main()
{
int a = 3;
int b = 7;
int c = 13;
printf("a=%d | b=%d |c=%d\n", a, b, c );
b = c-a;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 10 ( 13-3 )
a = c-2;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 8 ( 10-2 )
c= 140-22;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 118
return(1);
}
-
La multiplication : le signe '*'
il est donc possible dans le programme C
suivant ( test_x.c ) de faire :
int main()
{
int a = 3;
int b = 7;
int c = 0;
printf("a=%d | b=%d |c=%d\n", a, b, c );
c = a*b;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 21 ( 3*7 )
a = c*2;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 42 ( 21*2 )
b= 3*4;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 12
return(1);
}
-
La division : le signe '/'
il est donc possible dans le programme C
suivant ( test_div.c ) de faire :
int main()
{
int a = 30;
int b = 0;
int c = 2;
printf("a=%d | b=%d |c=%d\n", a, b, c );
b = a/c;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 15 ( 30/2 )
c = b/5;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 3 ( 15/5 )
a= 300/50;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 6
return(1);
}
Ensuite, un opérateur moins connu mais très utile, qui va nous
permettre de connaître le reste d'une division entre deux entiers.
-
Le modulo : le signe '%'
il est donc possible dans le programme C
suivant ( test_mod.c ) de faire :
#include
int main()
{
int a = 30;
int b = 7;
int c = 73;
printf("a=%d | b=%d |c=%d\n", a, b, c );
b = a%b;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 2 ( 30/7=4 RESTE=2 )
c = c%7;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 3 ( 73/7 = 10 RESTE 3 )
a= 299%29;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 9 ( 299/29 = 10 RESTE 9 )
return(1);
}
-
Les opérateurs et expressions d'affectation de variables
-
L'affectation simple : le signe '='
il est donc possible dans le programme C
suivant ( test_affect.c )de faire :
#include
int main()
{
int a = 3;
int b = 7;
int c = 0;
char caractere_saisi ='\0';
printf("a=%d | b=%d |c=%d\n", a, b, c );
c = a+b;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 10 ( 3+7 )
a = a+c;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 13 ( 10+3 )
b= 3+9;
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 12
printf("saisissez un caractere SVP\n");
caractere_saisi = getchar();
printf("caractere_saisi = %c\n", caractere_saisi );
return(1);
}
-
L'affectation avec incrémentation : le signe '=' precede d'un autre opérateur
il est donc possible dans le programme C
suivant ( test_incr.c ) de faire :
#include
int main()
{
int a = 3;
int b = 7;
int c = 10;
printf("a=%d | b=%d |c=%d\n", a, b, c );
c += 2; // equivalent a c = c+2
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 12 ( 10+2 )
a -= 3; // equivalent a a = a-3
printf("a=%d | b=%d |c=%d\n", a, b, c );
// a est maintenant egal a 9 ( 12-3 )
b *= 2; // equivalent a b = b * 2
printf("a=%d | b=%d |c=%d\n", a, b, c );
// b est maintenant egal a 14 ( 7*2 )
c /= 3; // equivalent a c = c/3
printf("a=%d | b=%d |c=%d\n", a, b, c );
// c est maintenant egal a 4 ( 12/3 )
return(1);
}
Ce 'mélange des opérateurs' peut aussi s'appliquer aux
opérateurs de manipulation de bits
-
Les opérateurs de comparaison
-
La comparaison d'égalité : le signe '=='
Cet opérateur va nous permettre de tester si deux variables
sont égales.
il est donc possible dans le programme C
suivant ( test_egal.c ) de faire :
#include
int main()
{
int a = 3;
int b = 7;
int c = 3;
printf("a=%d | b=%d |c=%d\n", a, b, c );
if ( a == c ) // ceci est vrai ( a est egal a c )
{
printf(" a est egal a c\n");
};
if ( a == 3 ) // ceci est vrai ( a est egal a c )
{
printf(" a est egal a 3\n");
};
if ( a == b ) // ceci est faux
{
printf(" a est egal a b\n");
}
else
{
printf("a n est pas egal a b\n");
}
if ( a == 20 ) // ceci est faux
{
printf(" a est egal a 20\n");
}
else
{
printf(" a n est pas egal a 20\n");
}
return(1);
}
-
La comparaison de différence : l'opérateur '!='
Cet opérateur va nous permettre de savoir si deux variables
sont différentes.
il est donc possible dans le programme C
suivant ( test_diff.c ) de faire :
#include
int main()
{
int a = 3;
int c = 10;
printf("a=%d | c=%d\n", a, c );
if ( a != c ) // ceci est vrai ( a est different a c )
{
printf(" a est different de c\n");
};
if ( a != 3 ) // ceci est faux ( a n'est pas different de 3 )
{
printf(" a est different de 3\n");
}
else
{
printf(" a n'est pas different de 3, donc a = 3\n");
}
return(1);
}
-
La comparaison d'infériorité : les opérateurs '<' et '<='
Ces opérateurs va nous permettre de savoir, respectivement, si une variable
est 'inférieure'(<) ou 'inférieure ou égale'(<=) à une autre.
il est donc possible dans le programme C
suivant ( test_inf.c ) de faire :
int main()
{
int a = 3;
int b = 10;
int c = 10;
if ( a <= c ) // ceci est vrai ( a est inferieur ou egal a c )
{
printf(" a est inferieur ou egal a c\n");
};
if ( b < c ) // ceci est faux ( b n'est pas inferieur a c )
{
printf(" b est inferieur a c\n");
};
if ( a <= 3 ) // ceci est vrai ( a est inferieur ou egal a 3 )
{
printf(" a est inferieur ou egal a 3\n");
};
if ( b < 10 ) // ceci est faux ( b n'est pas inferieur a 10 )
{
printf(" b est inferieur a 10\n");
};
return(1);
}
-
La comparaison de supériorité : les opérateurs '>' et '>='
Ces opérateurs va nous permettre de savoir, respectivement, si une
variable est 'supérieure'(>) ou 'supérieure ou égale'(>=) à une autre.
il est donc possible dans le programme C
suivant ( test_sup.c ) de faire :
#include
int main()
{
int a = 3;
int b = 10;
int c = 10;
printf("a=%d | b=%d |c=%d\n", a, b, c );
if ( b >= c ) // ceci est vrai ( b est superieur ou egal a c )
{
printf(" b est superieur ou egal a c\n");
}
if ( b > c ) // ceci est faux ( b n'est pas superieur a c )
{
printf(" b est superieur a c\n");
}
else
{
printf(" b n'est pas superieur a c\n");
}
if ( a >= 3 ) // ceci est vrai ( a est superieur ou egal a 3 )
{
printf(" a est superieur ou egal a 3\n");
}
if ( b > 10 ) // ceci est faux ( b n'est pas superieur a 10 )
{
printf(" b est superieur a 10\n");
}
else
{
printf(" b n'est pas superieur a 10\n");
}
return(1);
}
-
Les opérateurs d'incrémentation/décrémentation
Ici, rien de bien sorcier, seulement deux opérateurs ( ++ et -- ):
L'opérateur '++'
Cet opérateur sert a incrémenter ( ajouter 1 a une variable ).
il est donc possible dans le programme C
suivant ( test_incr2.c ) de faire :
#include
int main()
{
int a = 3;
printf("a=%d\n", a );
a++;
// Maintenant a est egal a 4
printf("a=%d\n", a );
a=a+1;
// Fait la meme chose que a++ ( incremente de 1 )
// Maintenant, a est egal a 5
printf("a=%d\n", a );
return(1);
}
L'opérateur '--'
Cet opérateur sert a décrémenter ( enlever 1 a une variable ).
il est donc possible dans le programme C
suivant ( test_decr.c ) de faire :
#include
int main()
{
int a = 10;
printf("a=%d\n", a );
a--;
// Maintenant a est egal a 9
printf("a=%d\n", a );
a=a-1;
// Fait la meme chose que a++ ( incremente de 1 )
// Maintenant, a est egal a 8
printf("a=%d\n", a );
return(1);
}
-
Les opérateurs de manipulation des bits
Attention, là, ça se corse carrément, personne ne vous en voudra de passer a la suite et de revenir
ici plus tard:
Les opérateurs logiques : '&', '|', '~' et '^'
Ces opérateurs servent à manipuler les bits qui composent une variable.
Les types de variables auxquels ces opérateurs s'appliquent sont :
- int : Les entiers
- long int: Les entiers longs
- unsigned int : Les entiers non signés ( supérieurs a 0 )
- char : un caractère
- unsigned char : un caractère aussi
ATTENTION, ces opérateurs ne s'appliquent pas aux types float, double
( chiffres réels avec virgule ).
Le et binaire : l'opérateur '&'
Cet opérateur sert a ne garder que les bits qui se trouvent dans les deux variables
auxquelles s'applique le et binaire.
il est donc possible dans le programme C
suivant ( test_et.c ) de faire :
#include
int main()
{
int a = 40; // en binaire, cela donne 00000000000000000000000000101000
int b = 0;
int c = 0;
int masque=8; // en binaire, cela donne 00000000000000000000000000001000
printf("a = %d\n", a);
b=a&masque;
// Permets d'eliminer tous les bits qui ne sont pas dans le masque
// b est donc egal a 8, c'est a dire en binaire 00000000000000000000000000001000
// car le bit qui signifie 32 ( le 6eme en partant de la droite ) a ete elimine
// ( il ne faisait pas partie du masque )
printf("b = %d\n", b);
a=64; // en binaire, cela donne 00000000000000000000000001000000
printf("a = %d\n", a);
b=a&masque;
printf("b = %d\n", b);
// Permets d'eliminer tous les bits qui ne sont pas dans le masque
// b est donc egal a 0, cest a dire en binaire 00000000000000000000000000000000
// car le bit qui signifie 64 ( le 7eme en partant de la droite ) a ete elimine
// ( il ne faisait pas partie du masque )
return(1);
}
Le ou binaire : l'opérateur '|'
Cet opérateur sert a ajouter certains bits a une variable.
il est donc possible dans le programme C
suivant ( test_ou.c ) de faire :
#include
int main()
{
int a = 8; // en binaire, cela donne 00000000000000000000000000001000
int bits_a_ajouter = 32; // en binaire, cela donne 00000000000000000000000000100000
int c=0;
printf("a = %d\n", a );
c= a|bits_a_ajouter; // On melange les bits des deux varaibles
printf("c = %d\n", c );
// c est dorenavant egal a 40 car le bit demande a ete ajoute a ceux de a
// cela donne en binaire : 00000000000000000000000000101000
return(1);
}
Le ou EXCLUSIF binaire : l'opérateur '^'
Cet opérateur sert a enlever certains bits a une variable.
La règle est la suivante :
Si les deux bits de même rang sont a 0, le resultat sera a 0.
Si les deux bits de même rang sont différents, le resulta sera a 1.
Si les deux bits de même rang sont a 1 le resultat sera a 0
Pour résumer, seuls les bits de même rang qui sont différents, seront a 1, et
tous les autres seront a 0.
il est donc possible dans le programme C
suivant ( test_ou_ex.c ) de faire :
#include
int main()
{
char a = 24; // en binaire, cela donne 00011000
char masque = 48; // en binaire, cela donne 00110000
int c=0;
printf("a = %d\n", a );
printf("masque = %d\n", masque );
c= a^masque; // On melange exclusivement les bits des deux varaibles
printf("c = %d\n", c );
// c est dorenavant egal a
// cela donne en binaire : 00101000
return(1);
}
Le complément a un unaire : l'opérateur '~'
Cet opérateur sert a inverser chacun des bits de la variable.
Chaque bit a 0 sera mis a 1
Chaque bit a 1 sera mis a 0
il est donc possible dans le programme C
suivant ( test_compl1.c ) de faire :
#include
int main()
{
unsigned char a = 2; // en binaire, cela donne 00000010
unsigned char b = 0;
printf("a = %d\n", a );
b=~a;
// On permute tous les bits
// b est donc egal a 253
// c'est a dire en binaire : 11111101
// car chaque bit qui etait a 0 est maintenant a 1
// et chaque bit qui etait a 1 est maintenant a 0
printf("b = %d\n", b );
return(1);
}
Les opérateurs de décalage de bits : '<<' et '>>'
Ces opérateurs servent à décaler les bits qui composent une variable.
Le décalage a gauche : l'opérateur '<<'
On peut decaler a gauche tous les bits d'une variable
comme dans le programme C suivant ( test_decal_gauche.c ) de faire :
#include
int main()
{
unsigned char a = 6; // en binaire, cela donne 00000110
unsigned char b = 0;
printf("a = %d\n", a );
// On decale tous les bits d'une position vers la gauche
b=a<<1;
// Apres decalage a gauche ( d'une position )
// de tous les bits de a, b est egal a 12
// c'est a dire en binaire : 00001100
printf("b = %d\n", b );
// On peut aussi tout decaler de deux positions vers la gauche
b=a<<2;
// Apres decalage a gauche ( de deux positions )
// de tous les bits de a, b est egal a 24
// c'est a dire en binaire : 00011000
printf("b = %d\n", b );
return(1);
}
Le décalage a droite : l'opérateur '>>'
On peut decaler a droite tous les bits d'une variable
comme dans le programme C suivant ( test_decal_droite.c ) de faire :
#include
int main()
{
unsigned char a = 48; // en binaire, cela donne 00110000
unsigned char b = 0;
printf("a = %d\n", a );
// On decale tous les bits d'une position vers la droite
b=a>>1;
// Apres decalage a droite ( d'une position )
// de tous les bits de a, b est egal a 24
// c'est a dire en binaire : 00011000
printf("b = %d\n", b );
// On peut aussi tout decaler de deux positions vers la droite
b=b>>2;
// Apres decalage a droite ( de deux positions )
// de tous les bits de b, b est egal a 6
// c'est a dire en binaire : 00000110
printf("b = %d\n", b );
return(1);
}
Comme vous pouvez le constater :
- Décaler d'une position a gauche équivaut à multiplier par deux
- Décaler de deux positions a gauche équivaut à multiplier par quatre
- Décaler de n positions a gauche équivaut à multiplier par ( n exposant 2)
- Décaler d'une position a droite équivaut à diviser par 2
- Décaler de deux positions a droite équivaut à diviser par 4
- Décaler de n positions a droite équivaut à diviser par ( n exposant 2)
Les bits qui sortent du champ ( la taille de la variable ), sont irrémédiablement perdus.
Dans le cas du décalage a gauche, les nouveaux bits qui apparaissent a gauche sont
initialisés avec des zéros.
Dans le cas du décalage a droite, les nouveaux bits qui apparaissent a droite sont
initialisés avec des zéros.
|
|
