FAQ CConsultez toutes les FAQ

Nombre d'auteurs : 27, nombre de questions : 175, dernière mise à jour : 17 décembre 2010  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'élement 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 :
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 :
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

Quelle est la différence entre = et == ?
Existe-t-il un type booléen en C ?

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'une 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éelle (si au moins l'une des deux l'est) possédant la plus grande capacité.

Code C :
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 à la première opérande
  • >>= effectue un décalage à droite du nombre de positions précisées et assigne le résultat à la première opérande

Code C :
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 :
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

Comment accéder à un bit d'une variable ?

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

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

Code C :
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

Comment accéder à un bit d'une variable ?

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

Que signifie E1 & E2 ?
Que signifie E1 | E2 ?

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 :
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 © 2014 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.

 
 
 
 
Partenaires

PlanetHoster
Ikoula