Opérateurs de programmation C

Un opérateur est un symbole qui opère sur une valeur ou une variable. Par exemple:+est un opérateur pour effectuer l’addition.

C dispose d’un large éventail d’opérateurs pour effectuer diverses opérations.


Opérateurs arithmétiques C

Un opérateur arithmétique effectue des opérations mathématiques telles que l’addition, la soustraction, la multiplication, la division, etc. sur des valeurs numériques (constantes et variables).

Opérateur Signification de l’opérateur
+ addition ou unaire plus
soustraction ou moins unaire
* multiplication
/ division
% reste après division (division modulo)

Exemple 1: Opérateurs arithmétiques

 // Working of arithmetic operators
#include <stdio.h>
int main()
{
    int a = 9,b = 4, c;
    
    c = a+b;
    printf("a+b = %d \n",c);
    c = a-b;
    printf("a-b = %d \n",c);
    c = a*b;
    printf("a*b = %d \n",c);
    c = a/b;
    printf("a/b = %d \n",c);
    c = a%b;
    printf("Remainder when a divided by b = %d \n",c);
    
    return 0;
} 

Production

a + b = 13
a-b = 5
a * b = 36
a / b = 2
Reste quand a divisé par b = 1

Les opérateurs + ,  - et * calcule l’addition, la soustraction et la multiplication respectivement comme vous vous y attendiez.

Dans le calcul normal, 9/4 = 2.25 . Cependant, la sortie est 2 dans le programme.

C’est parce que les deux variablesuneet b sont des nombres entiers. Par conséquent, la sortie est également un entier. Le compilateur néglige le terme après la virgule décimale et affiche la réponse 2 au lieu de 2.25 .

L’opérateur modulo % calcule le reste. Quand a=9 est divisé par b=4 , le reste est 1 . le % L’opérateur ne peut être utilisé qu’avec des entiers.

Supposer a = 5.0 ,  b = 2.0 ,  c = 5 et d = 2 . Puis en programmation C,

// L'un des opérandes est un nombre à virgule flottante
a / b = 2,5
a / d = 2,5
c / b = 2,5

// Les deux opérandes sont des entiers
c / d = 2

C Opérateurs d’incrémentation et de décrémentation

La programmation C a deux opérateurs incrémentés ++ et décrémenter -- pour changer la valeur d’un opérande (constante ou variable) par 1.

Incrément ++ augmente la valeur de 1 alors que la décrémente -- diminue la valeur de 1. Ces deux opérateurs sont des opérateurs unaires, c’est-à-dire qu’ils n’opèrent que sur un seul opérande.

Exemple 2: Opérateurs d’incrémentation et de décrémentation

 // Working of increment and decrement operators
#include <stdio.h>
int main()
{
    int a = 10, b = 100;
    float c = 10.5, d = 100.5;

    printf("++a = %d \n", ++a);
    printf("--b = %d \n", --b);
    printf("++c = %f \n", ++c);
    printf("--d = %f \n", --d);

    return 0;
} 

Production

++ a = 11
--b = 99
++ c = 11,500000
++ d = 99,500000

Ici, les opérateurs ++ et -- sont utilisés comme préfixes. Ces deux opérateurs peuvent également être utilisés comme suffixes comme a++ et a-- . Visitez cette page pour en savoir plus sur le fonctionnement des opérateurs d’incrémentation et de décrémentation lorsqu’ils sont utilisés comme suffixe.


Opérateurs d’affectation C

Un opérateur d’affectation est utilisé pour affecter une valeur à une variable. L’opérateur d’affectation le plus courant est = 

Opérateur Exemple Pareil que
= a = b a = b
+= a + = b a = a + b
-= a – = b a = a-b
*= a * = b a = a * b
/= a / = b a = a / b
%= a% = b a = a% b

Exemple 3: Opérateurs d’affectation

 // Working of assignment operators
#include <stdio.h>
int main()
{
    int a = 5, c;

    c = a;      // c is 5
    printf("c = %d\n", c);
    c += a;     // c is 10 
    printf("c = %d\n", c);
    c -= a;     // c is 5
    printf("c = %d\n", c);
    c *= a;     // c is 25
    printf("c = %d\n", c);
    c /= a;     // c is 5
    printf("c = %d\n", c);
    c %= a;     // c = 0
    printf("c = %d\n", c);

    return 0;
} 

Production

c = 5
c = 10
c = 5
c = 25
c = 5
c = 0

C Opérateurs relationnels

Un opérateur relationnel vérifie la relation entre deux opérandes. Si la relation est vraie, elle renvoie 1; si la relation est fausse, elle renvoie la valeur 0.

Les opérateurs relationnels sont utilisés dans la prise de décision et les boucles.

Opérateur Signification de l’opérateur Exemple
== Égal à  5 == 3 est évalué à 0
> Plus grand que  5 > 3 est évalué à 1
< Moins que  5 < 3 est évalué à 0
!= Pas égal à  5 != 3 est évalué à 1
>= Plus grand ou égal à  5 >= 3 est évalué à 1
<= Inférieur ou égal à  5 <= 3 est évalué à 0

Exemple 4: Opérateurs relationnels

 // Working of relational operators
#include <stdio.h>
int main()
{
    int a = 5, b = 5, c = 10;

    printf("%d == %d is %d \n", a, b, a == b);
    printf("%d == %d is %d \n", a, c, a == c);
    printf("%d > %d is %d \n", a, b, a > b);
    printf("%d > %d is %d \n", a, c, a > c);
    printf("%d < %d is %d \n", a, b, a < b);
    printf("%d < %d is %d \n", a, c, a < c);
    printf("%d != %d is %d \n", a, b, a != b);
    printf("%d != %d is %d \n", a, c, a != c);
    printf("%d >= %d is %d \n", a, b, a >= b);
    printf("%d >= %d is %d \n", a, c, a >= c);
    printf("%d <= %d is %d \n", a, b, a <= b);
    printf("%d <= %d is %d \n", a, c, a <= c);

    return 0;
} 

Production

5 == 5 is 1
5 == 10 is 0
5 > 5 is 0
5 > 10 is 0
5 < 5 is 0
5 < 10 is 1
5 != 5 is 0
5 != 10 is 1
5 >= 5 is 1
5 >= 10 is 0
5 <= 5 is 1
5 <= 10 is 1 

Opérateurs logiques C

Une expression contenant un opérateur logique renvoie 0 ou 1 selon que l’expression donne vrai ou faux. Les opérateurs logiques sont couramment utilisés dans la prise de décision en programmation C.

Opérateur Sens Exemple
&& ET logique. Vrai seulement si tous les opérandes sont vrais Si c = 5 et d = 2 alors, expression ((c==5) && (d>5)) est égal à 0.
|| OU logique. Vrai seulement si l’un ou l’autre des opérandes est vrai Si c = 5 et d = 2 alors, expression ((c==5) || (d>5)) est égal à 1.
! NON logique. Vrai seulement si l’opérande est 0 Si c = 5 alors, expression !(c==5) est égal à 0.

Exemple 5: Opérateurs logiques

 // Working of logical operators

#include <stdio.h>
int main()
{
    int a = 5, b = 5, c = 10, result;

    result = (a == b) && (c > b);
    printf("(a == b) && (c > b) is %d \n", result);
    result = (a == b) && (c < b);
    printf("(a == b) && (c < b) is %d \n", result);
    result = (a == b) || (c < b);
    printf("(a == b) || (c < b) is %d \n", result);
    result = (a != b) || (c < b);
    printf("(a != b) || (c < b) is %d \n", result);
    result = !(a != b);
    printf("!(a == b) is %d \n", result);
    result = !(a == b);
    printf("!(a == b) is %d \n", result);

    return 0;
}
 

Production

(a == b) && (c > b) is 1 
(a == b) && (c < b) is 0 
(a == b) || (c < b) is 1 
(a != b) || (c < b) is 0 
!(a != b) is 1 
!(a == b) is 0 

Explication du programme d’opérateur logique

  •  (a == b) && (c > 5) prend la valeur 1 car les deux opérandes (a == b) et (c > b) vaut 1 (vrai).
  •  (a == b) && (c < b) prend la valeur 0 car l’opérande (c < b) vaut 0 (faux).
  •  (a == b) || (c < b) donne la valeur 1 car (a = b) vaut 1 (vrai).
  •  (a != b) || (c < b) prend la valeur 0 car les deux opérandes (a != b) et (c < b) sont 0 (faux).
  •  !(a != b) prend la valeur 1 car l’opérande (a != b) vaut 0 (faux). Par conséquent,! (A! = B) vaut 1 (vrai).
  •  !(a == b) évalue à 0 car (a == b) vaut 1 (vrai). Par conséquent, !(a == b) vaut 0 (faux).

Opérateurs binaires C

Pendant le calcul, les opérations mathématiques telles que: l’addition, la soustraction, la multiplication, la division, etc. sont converties au niveau du bit, ce qui accélère le traitement et économise de l’énergie.

Les opérateurs au niveau du bit sont utilisés dans la programmation C pour effectuer des opérations au niveau du bit.

Les opérateurs Signification des opérateurs
& ET au niveau du bit
| OU au niveau du bit
^ OU exclusif au niveau du bit
~ Complément au niveau du bit
<< Shift gauche
>> Shift vers la droite

Visitez l’opérateur binaire en C pour en savoir plus.

Autres opérateurs


Opérateur virgule

Les opérateurs virgule sont utilisés pour relier les expressions associées. Par exemple:

 int a, c = 5, d; 

La taille de l’opérateur

le sizeof est un opérateur unaire qui renvoie la taille des données (constantes, variables, tableau, structure, etc.).

Exemple 6: taille de l’opérateur

 #include <stdio.h>
int main()
{
    int a;
    float b;
    double c;
    char d;
    printf("Size of int=%lu bytes\n",sizeof(a));
    printf("Size of float=%lu bytes\n",sizeof(b));
    printf("Size of double=%lu bytes\n",sizeof(c));
    printf("Size of char=%lu byte\n",sizeof(d));

    return 0;
} 

Production

Taille de int = 4 octets
Taille du flotteur = 4 octets
Taille du double = 8 octets
Taille du caractère = 1 octet

Autres opérateurs tels que l’opérateur ternaire ?: , opérateur de référence & , opérateur de déréférence * et opérateur de sélection des membres ->