Dans ce guide détaillé, nous aborderons les opérateurs en programmation C et leurs types.
Les opérateurs et leurs types en programmation C
Les opérateurs sont les symboles utilisés pour effectuer des tâches mathématiques spécifiques. Ils sont utilisés pour manipuler les données et les variables. Voici les différents types d'opérateurs en programmation C :
- Opérateurs arithmétiques
- Opérateurs unaires
- Opérateurs d'affectation
- Opérateurs logiques ou booléens
- Opérateurs relationnels
- Opérateurs conditionnels
- Opérateurs au niveau du bit
1 : Opérateurs arithmétiques
Ce sont les opérateurs utilisés pour effectuer des fonctions mathématiques de base comme l'addition, la soustraction ou la multiplication. Vous pouvez utiliser ces opérateurs sur presque tous les types de données intégrés de la programmation C. Voici les opérateurs arithmétiques utilisés en programmation C :
| Les opérateurs | Les fonctions |
| + | Ajouter 2 opérandes |
| – | Soustraire 2 opérandes |
| * | Multiplier 2 opérandes |
| / | Diviser 2 opérandes |
| % | L'opérateur module donne le reste de la division |
Exemple
Dans l'exemple ci-dessous, nous avons effectué les opérations arithmétiques mentionnées ci-dessus sur la variable X et la variable Y. La variable X contient la valeur 20 et Y contient la valeur 5 :
#include
entier principal ( )
{
entier X = vingt ;
entier ET = 5 ;
entier résultat ;
résultat = X + ET ;
printf ( 'L'addition de X et Y est : %d \n ' , résultat ) ;
résultat = X - ET ;
printf ( 'La soustraction de X et Y est : %d \n ' , résultat ) ;
résultat = X * ET ;
printf ( 'La multiplication de X et Y est : %d \n ' , résultat ) ;
résultat = X / ET ;
printf ( 'La division de X et Y est : %d \n ' , résultat ) ;
résultat = X % ET ;
printf ( 'La division du module de X et Y est : %d \n ' , résultat ) ;
retour 0 ;
}
2 : Opérateurs unaires
Il existe deux opérateurs unaires uniques qui ne sont pris en charge que par le langage C, les opérateurs d'incrémentation ++ et de décrémentation —. L'opérateur d'incrémentation ajoute 1 à l'opérande et l'opérateur de décrémentation soustrait 1 de l'opérande.
L'opérateur d'incrémentation s'écrit :
++ un ou un ++
L'opérateur de décrémentation est :
-- un ou un --Si nous utilisons l'opérateur d'incrémentation et de décrémentation comme préfixe, il ajoute ou soustrait d'abord la valeur de la variable, puis le résultat est affecté à la variable de gauche. Si les opérateurs sont ajoutés avant, il renvoie d'abord la valeur d'origine, puis l'opérande est ajouté ou soustrait de 1.
Exemple
Ci-dessous, nous avons attribué des valeurs à deux variables a et b et leur avons appliqué des opérateurs d'incrémentation et de décrémentation :
#includeentier principal ( )
{
entier un = quinze , b = dix ;
printf ( '++a = %d \n ' , ++ un ) ;
printf ( 'a++ = %d \n ' , un ++ ) ;
retour 0 ;
}
3 : Opérateur d'affectation
Un opérateur d'affectation (=) est utilisé pour affecter la valeur à la variable dans le programme. Voici les opérateurs d'affectation mentionnés :
| Les opérateurs | Fonction |
| = | Attribuez les valeurs à l'opérande |
| += | Ajouter la valeur de l'opérande présent à droite à l'opérande de gauche |
| -= | Soustraire la valeur de l'opérande droit de l'opérande gauche |
| *= | Multiplier la valeur de l'opérande droit par l'opérande gauche |
| /= | Diviser la valeur de l'opérande de droite par l'opérande de gauche |
| %= | Prenez le module de deux valeurs et attribuez la valeur à l'opérande de gauche |
Exemple
Nous avons démontré le fonctionnement des opérateurs d'affectation sur les deux opérandes X et Y dans l'exemple ci-dessous :
#includeentier principal ( )
{
entier X = dix ;
entier résultat ;
résultat = X ;
printf ( 'Valeur du résultat = %d \n ' , résultat ) ;
résultat += X ;
printf ( 'Valeur du résultat = %d \n ' , résultat ) ;
résultat -= X ;
printf ( 'Valeur du résultat = %d \n ' , résultat ) ;
résultat *= X ;
printf ( 'Valeur du résultat = %d \n ' , résultat ) ;
résultat /= X ;
printf ( 'Valeur du résultat = %d \n ' , résultat ) ;
retour 0 ;
}
4 : Opérateurs relationnels
Les opérateurs relationnels sont utilisés en programmation C pour vérifier la relation entre deux variables. Il peut être utilisé pour comparer les prix des articles ou l'âge de deux personnes Voici les opérateurs relationnels utilisés en programmation C :
| Les opérateurs | Les fonctions |
| == | Égal à |
| > | Plus grand que |
| < | Moins que |
| >= | Supérieur à égal à |
| <= | Moins qu'égal à |
| != | Pas égal à |
Exemple
L'exemple ci-dessous montre le fonctionnement des opérateurs relationnels en programmation C :
#includeentier principal ( )
{
entier un = 9 ;
entier b = dix ;
printf ( '%d == %d est %d \n ' , un , b , un == b ) ;
printf ( '%d > %d est %d \n ' , un , b , un > b ) ;
printf ( '%d < %d est %d \n ' , un , b , un < b ) ;
printf ( '%d != %d est %d \n ' , un , b , un != b ) ;
printf ( '%d >= %d est %d \n ' , un , b , un >= b ) ;
printf ( '%d <= %d est %d \n ' , un , b , un <= b ) ;
retour 0 ;
}
5 : Opérateurs logiques
Il existe quatre opérateurs logiques pris en charge par le langage C :
| Les opérateurs | Fonction |
| ET logique (&&) | Vrai uniquement si toutes les conditions sont satisfaites |
| OU logique (||) | Si une seule condition satisfait le résultat est vrai |
| NON logique (!) | Si l'opérande vaut 0, le résultat est vrai |
| Au niveau du bit NON (~). | Inverse tous les bits de l'opérande |
Exemple
L'exemple de code ci-dessous explique le fonctionnement des opérateurs logiques en C :
#includeentier principal ( )
{
entier X = dix , ET = 4 , AVEC = dix , résultat ;
résultat = ( X == ET ) && ( AVEC > ET ) ;
printf ( '(X == Y) && (Z > Y) est %d \n ' , résultat ) ;
résultat = ( X == ET ) && ( AVEC < ET ) ;
printf ( '(X == Y) && (Z < Y) est %d \n ' , résultat ) ;
résultat = ( X == ET ) || ( AVEC < ET ) ;
printf ( '(X == Y) || (Z < Y) est %d \n ' , résultat ) ;
résultat = ( X != ET ) || ( AVEC < ET ) ;
printf ( '(X != Y) || (Z < Y) vaut %d \n ' , résultat ) ;
résultat = ! ( X != ET ) ;
printf ( '!(X != Y) est %d \n ' , résultat ) ;
résultat = ! ( X == ET ) ;
printf ( '!(X == Y) vaut %d \n ' , résultat ) ;
résultat = ! ( X > ET ) ;
printf ( '!(X > Y) vaut %d \n ' , résultat ) ;
retour 0 ;
}
6 : Opérateurs conditionnels
L'opérateur conditionnel en C est également connu sous le nom de opérateur ternaire car il prend trois opérandes - la condition, l'instruction 1 et l'instruction 2. Il évalue la condition et renvoie l'instruction 1 ou l'instruction 2, selon le résultat d'une condition donnée qui peut être vraie ou fausse
Condition ? Déclaration 1 : Déclaration 2- Condition: Une expression booléenne qui vérifie qu'elle est vraie ou fausse.
- Déclaration 1 : Une expression qui est évaluée si la condition est vraie.
- Déclaration 2 : Une expression qui est évaluée si la condition est fausse.
Exemple
Dans l'exemple ci-dessous, j'ai attribué la valeur au nombre, puis appliqué la condition. Si la condition est vraie, l'instruction 1 sera la sortie et si la condition est fausse, l'instruction 2 sera la sortie :
#includeentier principal ( )
{
entier nombre = dix ;
( nombre < vingt ) ? ( printf ( 'C'est moins que le numéro 20 !' ) ) : ( printf ( 'Il est supérieur au nombre 20 !' ) ) ;
retour 0 ;
}
7 : Opérateurs au niveau du bit
Opérateurs au niveau du bit en C manipulent les données au niveau du bit, ce qui signifie qu'elles opèrent sur des bits individuels dans des types de données comme des entiers. Ils ne peuvent pas être appliqués au double et au flotteur et sont utilisés pour tester les bits et les déplacer vers la droite ou vers la gauche.
Les opérateurs au niveau du bit en programmation C sont donnés dans le tableau ci-dessous :
| Les opérateurs | Fonction |
| & | ET au niveau du bit |
| | | OU au niveau du bit |
| ^ | OU exclusif au niveau du bit |
| << | Décalage à gauche |
| >> | Décalage à droite |
| ~ | Complément à un |
Exemple
L'exemple suivant montre un programme C qui utilise des opérateurs au niveau du bit :
#includeentier principal ( ) {
entier un = 13 ; // binaire 1101
entier b = 7 ; // binaire 0111
entier résultat ;
// AND au niveau du bit
résultat = un & b ; // 1101 & 0111 = 0101 (décimal 5)
printf ( 'a & b = %u \n ' , résultat ) ;
// OU au niveau du bit
résultat = un | b ; // 1101 | 0111 = 1111 (décimal 15)
printf ( 'a | b = %u \n ' , résultat ) ;
// XOR au niveau du bit
résultat = un ^ b ; // 1101 ^ 0111 = 1010 (décimal 10)
printf ( 'a ^ b = %u \n ' , résultat ) ;
// Décalage à gauche au niveau du bit
résultat = un << 2 ; // 1101 << 2 = 110100 (décimal 52)
printf ( 'a << 2 = %u \n ' , résultat ) ;
// Décalage à droite au niveau du bit
résultat = un >> 2 ; // 1101 >> 2 = 0011 (décimal 3)
printf ( 'a >> 2 = %u \n ' , résultat ) ;
// NON au niveau du bit
résultat = ~ un ; // ~1101 = 0010 (représentation décimale du complément à 2 de -14)
printf ( '~a = %d \n ' , résultat ) ;
retour 0 ;
}
Note: Les opérateurs au niveau du bit sont utilisés pour effectuer des tâches au niveau du bit, ce qui signifie qu'ils opèrent sur des bits individuels dans un nombre binaire. Les opérateurs booléens, quant à eux, sont utilisés pour effectuer des opérations sur des valeurs logiques. Ils fonctionnent sur des valeurs booléennes (vrai/faux ou 1/0) et sont couramment utilisés dans les processus de prise de décision ou les déclarations conditionnelles.
Conclusion
Un opérateur est un symbole qui demande au compilateur d'exécuter certaines fonctions. Le langage C possède plusieurs opérateurs intégrés, notamment arithmétique, unaire, d'affectation, logique, relationnel, conditionnel, booléen et au niveau du bit. Nous les avons discutés en détail et les avons démontrés avec l'exemple de sortie. Lisez la section ci-dessus du guide pour obtenir des informations détaillées sur ces opérateurs.