IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ CConsultez toutes les FAQ

Nombre d'auteurs : 35, nombre de questions : 194, dernière mise à jour : 18 février 2018  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de www.developpez.com et de l'expérience personnelle des auteurs.

Je tiens à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.

SommaireLes types et les variablesLes opérateurs (12)
précédent sommaire suivant
 

L'opérateur = est l'opérateur d'assignation, c'est-à-dire qu'il attribue la valeur qui se trouve à sa droite à l'élément qui se trouve à sa gauche.
L'opérateur == est l'opérateur de comparaison, c'est-à-dire qu'il renvoie vrai si les éléments à sa gauche et à sa droite sont identiques.

Mis à jour le 15 mai 2003 LFE

Parce qu'en C, l'opérateur = est valide dans un test bien que la plupart des compilateurs émettent un avertissement à ce sujet. Le programme suivant :

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h> 
  
int main(void) 
{ 
    int a = 5, b = 10; 
  
    if (a = b) 
    { 
        /* Vrai car l'expression a = b vaut la valeur de a après affectation c'est-a-dire : 10.  */ 
        /* Or en C, toute valeur différente de 0 (par exemple 10) vaut 'VRAI', d’où le résultat. */ 
  
        printf("Coucou !\n"); 
    } 
  
    return 0; 
}
Affichera Coucou !

Le programme suivant par contre n'affichera rien du tout.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h> 
  
int main(void) 
{ 
    int a = 5, b = 10; 
  
    if (a == b) 
    { 
        /* Faux car a (5) est différent de b (10). */ 
  
        printf("Coucou !\n"); 
    } 
  
    return 0; 
}

Mis à jour le 15 mai 2003 LFE Melem

L'opérateur ?: est un opérateur ternaire c'est-à-dire qu'il prend 3 opérandes. L'expression a ? b : c vaut b si a vaut 'vrai' et c sinon. Ainsi, avec l'instruction x = (a == b) ? 5 : 10;, x vaut 5 si (a == b) et 10 dans le cas contraire.

Mis à jour le 15 mai 2003 LFE

Sur un nombre positif, l'opérateur modulo (%) correspond strictement à sa définition mathématique, c'est-à-dire calcule le reste de la division entière. Par exemple 5 % 3 donne 2 (reste de la division de 5 par 3). Retenez donc qu'un nombre quelconque modulo N sera toujours compris entre 0 et N, N exclu. La norme n'exige pas que l'opérateur modulo puisse également s'utiliser avec un nombre négatif.

Mis à jour le 2 mars 2003 Bob

Voici un petit rappel des règles s'appliquant aux divisions en C.

  • Si les deux opérandes sont de type entier (char, int, short, long, long long) alors la division effectuée sera entière, et donnera de ce fait toujours un résultat entier.
  • Si au moins l'un des deux opérandes est de type flottant (float, double, long double) alors la division effectuée sera réelle, donnant un résultat décimal.
  • Le type du résultat de la division est celui de l'opérande réel (si au moins l'un des deux l'est) possédant la plus grande capacité.

Code C : Sélectionner tout
1
2
3
4
double r1 = 7 / 10;       /* r1 = 0    */ 
double r2 = 7.0 / 10;     /* r2 = 0.7  */ 
double r3 = 7 / 10.0f;    /* r3 = 0.7f */ 
double r4 = 7.0 / 10.0f;  /* r4 = 0.7  */

Mis à jour le 11 septembre 2006 Laurent Gomila

L'opérateur ++ est un opérateur d'incrémentation : il ajoute 1 à la variable à laquelle il est appliqué. La seule différence est que i++ permet d'utiliser et seulement ensuite de l'incrémenter, alors que ++i incrémente la variable avant de l'utiliser.

L'opérateur -- fonctionne exactement de la même façon, sauf qu'il s'agit d'une décrémentation.

Mis à jour le 2 février 2003 LFE

Ces deux opérateurs effectuent un déplacement (shift) des bits dans une variable.

  • << effectue un décalage à gauche du nombre de positions précisées
  • >> effectue un décalage à droite du nombre de positions précisées
  • <<= effectue un décalage à gauche du nombre de positions précisées et assigne le résultat au premier opérande
  • >>= effectue un décalage à droite du nombre de positions précisées et assigne le résultat au premier opérande

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
unsigned char c1, c2, c3, c4; 
  
c1 = 5; /* 00000101 */ 
c2 = 4; /* 00000100 */ 
  
c3 = c1 << 2; /* 00000101(c1) -> 00010100(c3) */ 
c4 = c2 >> 2; /* 00000100(c2) -> 00000001(c4) */ 
  
c1 <<= 2; /* 00000101(c1) -> 00010100(c1) */ 
c2 >>= 2; /* 00000100(c2) -> 00000001(c2) */

Mis à jour le 15 mai 2003 gl LFE

Cela signifie qu'on effectue un ET bit à bit entre E1 et E2. Le bit résultant est 1 lorsque les deux bits sont à 1, 0 sinon.

0 & 0 -> 0
0 & 1 -> 0
1 & 0 -> 0
1 & 1 -> 1

Code C : Sélectionner tout
1
2
3
4
5
++ unsigned char c1, c2; 
++ 
++ c1 = 5;      /* 00000101 */ 
++ c2 = 4;      /* 00000100 */ 
-> c1 & c2 = 4  /* 00000100 */
On dit qu'on a masqué c1 avec c2. On appelle ça (c2) un masque car il permet de cacher (masquer) certains bits de c1 (cacher signifie mettre à zéro).

Mis à jour le 12 avril 2003 gl LFE

Cela signifie qu'on effectue un OU bit à bit entre E1 et E2. Le bit résultant est 1 lorsqu'un au moins des 2 bits est à 1, 0 sinon.

0 | 0 -> 0
0 | 1 -> 1
1 | 0 -> 1
1 | 1 -> 1

Code C : Sélectionner tout
1
2
3
4
5
++ unsigned char c1, c2; 
++ 
++ c1 = 5;      /* 00000101 */ 
++ c2 = 4;      /* 00000100 */ 
-> c1 | c2 = 5  /* 00000101 */

Mis à jour le 12 avril 2003 gl LFE

L'opérateur && désigne l'opérateur ET logique. E1 && E2 correspond à l'expression « E1 est vrai ET E2 est vrai ». L'opérateur & désigne l'opérateur ET binaire. E1 & E2 retourne donc le ET bit à bit entre E1 et E2.

De même, || désigne l'opérateur OU logique. E1 || E2 correspond à l'expression « E1 est vrai OU E2 est vrai ». L'opérateur | désigne l'opérateur OU binaire. E1 | E2 retourne donc le OU bit à bit entre E1 et E2.

L'opérateur ^ quant à lui permet de faire un OU EXCLUSIF (XOR) binaire. Il n'y a pas d'opérateur qui fasse le OU EXCLUSIF logique (E1 '^^' E2 = (E1 && !E2) || (E2 && !E1)).

Mis à jour le 12 avril 2003 gl LFE

Lors de l'utilisation des opérateurs && et ||, les différents membres sont évalués de gauche à droite. L'évaluation est stoppée dès que le résultat final est connu de manière certaine, c'est-à-dire :

  • si lors de l'utilisation de && un membre est évalué à faux ;
  • si lors de l'utilisation de || un membre est évalué à vrai.

Mis à jour le 11 septembre 2006 gl

Il est souvent intéressant d'accéder aux bits d'une variable, ce qui permet, par exemple, de stocker 8 flags (nombre de bits minimal d'un char) dans un seul char plutôt que d'utiliser un char par flag. Pour manipuler les bits, il suffit d'utiliser les opérateurs du langage : & (opérateur ET) pour tester un bit, | (opérateur OU) pour positionner un bit et & (opérateur ET) et ~ (opérateur NON) pour enlever un bit

Voici deux petites macros, permettant respectivement de positionner un flag et de lire la valeur d'un flag :

Code C : Sélectionner tout
1
2
3
#define SET(flag, bit) ((flag) |= (1 << (bit))) 
#define CLEAR(flag, bit) ((flag) &= ~(1 << (bit))) 
#define GET(flag, bit) ((flag) & (1 << (bit)))
Remarque : dans ces macros, nous considérons que le bit de poids faible est le bit 0.

Mis à jour le 29 novembre 2004 gl

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.