Citation : Maëlan

NB : Si jamais un évêque à plume du forum C (ou n’importe qui de façon générale, n’attendez pas les plumes) vient vous sermonner que cette solution n’est pas portable, vous lui mettrez sous le bec cet extrait de la norme :

Citation : @che

PS: Il (Elle ?)

Citation : @che

De plus, il serrait utile de rajouter que ça ne marche pas pour les lettres (un avertissement ou truc dans le même genre) ...

Citation : Maëlan

Pendant que j’y suis, d’autres propositions en vrac…

[8][12] Que signifie « ++i » ? Quelle différence avec « i++ » ?

Saviez-vous qu’il existe deux opérateurs d’incrémentation, et autant pour la décrémentation ? En fait, on parle d’incrémentation ou de décrémentation postfixée (n++, n--) ou préfixée (++n, --n). La préfixée ressemble beaucoup à la postfixée, mis à part que l’opérateur se place avant son opérande.
Quelle est la différence ? Les opérateurs préfixés modifient la variable, puis renvoient sa nouvelle valeur, alors que les postfixés renvoient la valeur de la variable avant de la modifier.
Exemple :

int a=5,  b=5;
printf("%d\n", ++a);   // affiche 6
// a vaut maintenant 6
printf("%d\n", b++);   // affiche 5
// b vaut maintenant 6

Un point tordu pour finir : si f est une fonction, dans l’expression f(n++), l’argument de f aura l’ancienne valeur de n, mais n sera incrémenté avant l’exécution de f…

L’intérêt de tout ça ? L’opérateur préfixé est plus rapide que le postfixé. En effet, le postfixé impose de créer une variable temporaire pour renvoyer la valeur de la variable avant sa modification. Vous pouvez donc faire une micro-optimisation de vos programmes en remplaçant vos [in/dé]crémentations postfixées par des préfixées dès que possible, par exemple dans vos boucles : for(i=0; i<n; ++i).
Cependant, en pratique, votre compilateur favori est sans doute capable de faire une telle optimisation tout seul. Voyant que vous ne récupérez pas la valeur de retour de l'expression (i++), il sait qu’il peut la remplacer par (++i).

En C++, c’est différent. En effet, dans le cas d’un objet, les opérateurs ++ et -- sont en fait des appels de fonctions maquillés par la surcharge des opérateurs, et le compilateur ne peut donc pas optimiser (contrairement au C où il sait ce que font ces opérateurs).
De plus, en C++, le gain de performances en utilisant la version préfixée peut être significatif car si ça se trouve, les fonctions derrière sont très lourdes et la version préfixée permet de les simplifier largement. Prenez donc l’habitude d’utiliser les bons opérateurs.

Pour plus d’informations à ce sujet, allez voir ici.

Citation : Maëlan

Que pensez-vous de rajouter un tableau récapitulatif des opérateurs du C (un peu comme cela a été fait pour le C++) ? cf ma bio...

Citation : informaticienzero

Qui c'est cet "évêque à plumes" ?

Citation : informaticienzero

C'est très bien, je peux aider à la rédaction si tu veux.

Citation : informaticienzero

Pourquoi ne pas rajouter une partie sur les mots-clefs du C ? Avec ceux apportés par C99 / C11. Ça existe déjà sur le forum C++ mais c'est pas top à mon goût. De plus, un débutant C n'a pas le réflexe d'aller voir les forums C++.

Citation : @che

En fait, il fallait suivre un autre sujet pour comprendre, j'ai plus le lien par-contre ^^"

Citation : @che

Citation : informaticienzero

Qui c'est cet "évêque à plumes" ?

Cf avatar de Taurre ... Tux en "évêque" => Évêque à plumes ...

En fait, il fallait suivre un autre sujet pour comprendre, j'ai plus le lien par-contre ^^"

Citation : Taurre

Pour le sujet, c'était celui-ci

Citation : Taurre

Pour les mots-clés, j'en parle dans le dernier chapitre de mon tutoriel sur les identificateurs (il faudrait d'ailleurs que je le mette à jour par rapport au C11). Maintenant, c'est vrai qu'un débutant n'ira pas forcément le lire étant donné sa difficulté. On pourrait donc effectivement les listés dans la FAQ.

Citation : informaticienzero

Je pensais plus à faire une liste de tous les mot-clefs avec des explications sur chacun d'eux.

Citation : informaticienzero

C'est vrai, mais je pense qu'un tutoriel expliquant les mots-clefs ne passerait pas en validation, à moins d'être vraiment le plus complet et exhaustif possible.

Citation : Maëlan

L’intérêt de tout ça ? L’opérateur préfixé est plus rapide que le postfixé. En effet, le postfixé impose de créer une variable temporaire pour renvoyer la valeur de la variable avant sa modification. Vous pouvez donc faire une micro-optimisation de vos programmes en remplaçant vos [in/dé]crémentations postfixées par des préfixées dès que possible, par exemple dans vos boucles : for(i=0; i<n; ++i).

Citation : Maëlan

Je préfère mon tableau, mais tes explications (Taurre) sont peut-être plus claires (surtout sur l’associativité). Je pense aussi que c’est le moment ou jamais de parler des opérateurs qui s’écrivent pareil. Au final, on pourrait faire une soupe de nos deux rédactions ?

Citation : Maëlan

Par contre, on ne dit pas la même chose concernant ++ et -- préfixés / postfixés (ces derniers sont prioritaires et ont une associativité contraire). N’ayant jamais fait attention à ça, je te fais confiance.

Citation : Norme C11 6.5 § 2 note 85 p 76

The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
as the order of the major subclauses of this subclause, highest precedence first.

Citation : Norme C11 6.5 § 3 p 76

The grouping of operators and operands is indicated by the syntax.

Syntax
      postfix-expression:
               primary-expression
               postfix-expression [ expression ]
               postfix-expression ( argument-expression-listopt )
               postfix-expression . identifier
               postfix-expression -> identifier
               postfix-expression ++
               postfix-expression --
               ( type-name ) { initializer-list }
               ( type-name ) { initializer-list , }

      argument-expression-list:
               assignment-expression
               argument-expression-list , assignment-expression

Citation : Maëlan

Concernant la liste des mots-clé, ça a déjà été fait très bien sur le forum C++, on ne pourrait pas se contenter de donner le lien (en précisant ceux qui sont présents en C)?

Citation : lucas-84

Une autre petite chose hors sujet : une foire aux questions n'est-t-elle pas, justement, un endroit où l'on retrouve les questions les plus fréquemment posées ? Ma foi, je vois rarement des questions sur les opérateurs. Quitte à faire un ensemble de ressources complètes et références, autant ajouter le plus de choses possibles.

Citation : lucas-84

(c'est ce qui me gêne, j'ai l'impression que les nouveaux arrivants se noient dans les informations de la FAQ, qui ne sont pourtant pas bien importantes. Ou alors ne daignent-ils même pas la regarder ?).

Citation : lucas-84

Ah, et une dernière chose : on ne pourrait pas mettre un peu plus en valeur la section sur le vidage de buffer ? Le nombre de sujets où l'on se retrouve avec cette question...

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

struct Exemple {
    int  a  :2,
         b  :3,
         c  :1,
         d  :1,
         e  :1;
    char f;
};

/** Structure contenant 8 booléens **/
struct Booleans {
    _Bool  b1  :1,    /* (le type _Bool est apparu en C99) */
           b2  :1,
           b3  :1,    /* Ces membres n’utilisent qu’un bit et ne peuvent */
           b4  :1,    /*  donc valoir que 0 ou 1. */
           b5  :1,
           b6  :1,
           b7  :1,
           b8  :1;
};

/** Exemple d’utilisation **/
struct Booleans  myBools =  {1, 1, 0, 1, 0, 1, 1, 0};
myBools.b3 =  1;
myBools.b7 =  myBools.b2;
if(myBools.b1)    { … }
          /* ⇒ On s’en sert comme des membres normaux. */

/*/ Taille totale de la structure **/
printf("sizeof Booleans: %u\n", sizeof(struct Booleans) );
    // ↑ probablement 1
printf("sizeof _Bool[8]: %u\n", sizeof(_Bool[8]) );
    // ↑ probalement 8
          /* ⇒ Si on n’avait pas eu recours aux champs de bits pour stocker
            8 booléens (un tableau par exemple), on aurait utilisé plus de
            place. */

struct StructureAvecBourrage {
    int  a  :3,
            :2,    /* champ anonyme de 2 bits */
         b  :3;
};

struct StructureAvecAlignement {
    int  a  :3,
         b  :2,
            :0,    /* champ anonyme s’étendant jusqu’à la fin du « int » englobant */
         c  :3;    /* champ commençant au « int » suivant */
};

• Vous ne pouvez faire ceci que pour des membres de structure ou union.
• Cela se limite aux types entiers int, signed int, unsigned int ou _Bool (depuis C99). Les champs de bits sont du même type que leur unité « englobante ». Dans le cas de int, le fait que les champs de bits soient signés ou non est au choix de l’implémentation.
• La norme n’impose pas d’ordre pour les champs de bits (des bits de poids forts vers les bits de poids faibles ou le contraire) : c’est à l’implémentation de trancher.
  
  Attention donc si vous tentez de gérer un ensemble de flags avec une union de cette façon :

  typedef union {
      uint8_t flags;        /* ensemble de 8 flags */
      struct {              /* accès individuel aux divers flags */
          _Bool  hasBuffer    :1,
                 usesTruck    :1,
                 hasDrunk     :1,
                 knowsTruth   :1,
                 hasReadDraft :1,
                 hasSeenWolf  :1,
                 canFly       :1,
                 isLastMohic  :1;
      } flag;
  } Flags;
  

  
  Pour les mêmes valeurs de flags, l’entier les englobant tous (le membre flags) pourra avoir une valeur différente d’un système à l’autre, selon l’ordre dans lequel sont rangés les champs de bits.
  
  
  
• S’il ne reste plus assez de place dans l’unité de stockage pour le prochain champ de bits, celui-ci peut être décalé pour commencer avec l’unité suivante (donc ajout de bits inutilisés), ou à cheval sur les deux unités (ce qui diminue les performances) ; à l’implémentation de choisir.

/−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

printf("sizeof Booleans: %u\n", sizeof(struct Booleans) );
printf("sizeof _Bool[8]: %u\n", sizeof(struct _Bool[8]) );

Citation : Taurre

Au passage, j'ai appris pas mal de choses à leurs sujets, merci beaucoup

Citation : Taurre

Aussi, j'ai une question qui me taraude en lisant ceci: imaginons que l'on ait un champ de bits de type unsigned int composé de 3 bits. Ce dernier peut contenir des valeurs de 0 à 7, jusque là tout va bien. Mais, que se passe-t-il si je dépasse sa capacité? J'ai un comportement déterminé comme pour tout type non signé (Norme C11 6.3.1.3 § 2 p 51) ou bien c'est un comportement indéterminé?

• la représentation des entiers signés (il est dit explicitement que les champs de bits non signés utilisent la « notation binaire pure ») : les entiers signés « normaux » utilisent le complément à 2, le complément à 1 ou le « signe et magnitude » (implementation-defined) ;
• le dépassement de capacité : pour les entiers non signés normaux, on fait simplement un modulo, pour les signés c’est selon l’implémentation il me semble ;
• …

Citation : Maëlan

Au fait, j’ai fait une grosse erreur dans le bout de code que tu as cité. Apparemment, elle t’a échappé aussi.

Citation : Norme C11 6.7.2.1 § 10 p 114

A bit-field is interpreted as having a signed or unsigned integer type consisting of the
specified number of bits.

Citation : Norme C11 6.3.1.3 § 2 p 51

Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
subtracting one more than the maximum value that can be represented in the new type
until the value is in the range of the new type.

Citation : Taurre

Sinon, je me demande s'il ne serait pas bon de supprimer le passage concernant le C++ dans l'entrée traitant des opérateurs de post/pré incrémentation/décrémentation. En effet, au final c'est la FAQ du forum C, il n'y a donc pas lieu de parler du C++.

Citation

Conclusion : les champs de bits sont sympathiques et parfois bien pratiques, mais si vous visez la portabilité, mieux vaut les oublier. Si vous avez vraiment besoin de condenser vos données, utilisez manuellement les opérations binaires (&, |, ^).

[?][?] Quels sont les opérateurs du langage C ? Comment se combinent-ils ?


Un opérateur peut être défini comme le symbole d'une opération mathématique ou logique. Par exemple, l'opérateur + est le symbole de l’opération mathématique d’addition et l’opérateur && celui de l’opération logique de conjonction. Toutefois, le langage C ne se limite pas à ses deux types d’opérations. En effet, sizeof et & par exemple sont tous deux des opérateurs et permettent respectivement d’obtenir la taille et l’adresse de leurs opérandes.

Mais, le C compte combien d’opérateurs alors ?

Hé bien, le langage C intègre de nombreux opérateurs : 47 en tout (48 depuis C11) ! Certains sont plus fréquents que d'autres, mais tous ont leur utilité. Le tutoriel officiel de M@teo21, comme de nombreux cours pour débutants, ne les présente pas tous car ils ne sont pas utiles pour commencer.

Ci-dessous, un grand tableau vous les représente tous. Le but n’est pas de tous les expliquer ici, mais d’en offrir une vue d’ensemble et de rappeler leur caractéristiques : arité, priorité et associativité.

Rhôô, les gros mots ! Ça veut dire quoi tout ça ?

On va tout vous expliquer :

• Chaque opérateur a une ou des opérandes. Les opérandes, ce sont les expressions sur lesquelles on effectue l'opération. Par exemple, l'opérateur + nécessite deux opérandes (une avant et une après) : dans A+B, ce sont A et B.
  
  On appelle arité le nombre d’opérandes d’un opérateur. On dit qu'un opérateur est « unaire » s'il n'a qu'une seule opérande. Par exemple, ++ (comme dans A++) et sizeof (comme dans sizeof A) sont des opérateurs unaires. De même, les opérateurs ayant deux opérandes sont dits « binaires » (rien à voir avec la base 2), et ceux en ayant trois « ternaires » (il n’en existe qu'un en C, l'opérateur ? : qui s’utilise ainsi : A?B:C et qui est simplement appelé opérateur ternaire).
  
  Certains opérateurs s’écrivent de façon identique (même symbole) mais se différencient par leur arité (1 ou 2). Il y en a 4 en tout, en voici la liste :
  

  Symbole	Opérateur unaire	Opérateur binaire
  Usage	Description	Usage	Description
  +	+A	signe : détermine le signe de l’expression A	A + B	addition ou soustraction : retourne la somme ou la différence de A et B
  —	-A	A - B
  *	*A	indirection : retourne la valeur pointée par A	A * B	multiplication : retourne le produit de A et B
  &	&A	référence : retourne l’adresse de la variable A	A & B	ET binaire (opérateur bit-à-bit) : retourne l’entier tel que chaque bit est à 1 si et seulement si le bit correspondant de chaque opérande est à 1

  </span>
  
• La priorité des opérateurs permet de déterminer l’ordre dans lequel les opérations composant une expression seront effectuées. Prenons un exemple simple, l’expression 5 + 4 * 3. Il y a deux manières de calculer sa valeur :
  
  — effectuer l'addition puis la multiplication : ( (5 + 4) * 3 ) ;
  — effectuer la multiplication puis l'addition : ( 5 + (4 * 3) ).
  
  L’ordre des opérations est extrêmement important puisqu’il va déterminer la valeur de l’expression. Dans le premier cas on obtiendra 27, et dans l’autre on obtiendra 17. Grâce à la priorité, nous savons que la multiplication doit s’effectuer avant l’addition (la multiplication est prioritaire sur l’addition) et que la valeur de l’expression sera donc de 17.
  Pour contourner les priorités (dans notre exemple, si l’on veut effectuer l’addition avant la multiplication), on met des parenthèses : (5 + 4) * 3 nous donnera bien 27.
  
  Le tableau ci-dessous est organisé de telle sorte qu’un opérateur prioritaire sur un autre sera placé plus haut que ce dernier ; deux opérateurs de même priorité seront sur la même ligne.
  
  
• Malheureusement, la priorité des opérateurs ne suffit pas à lever toute ambigüité. En effet, que faire dans les cas où les opérateurs ont la même priorité ? Par exemple, dans l’expression 5 + 4 - 3, qui de l’addition ou de la soustraction doit être réalisée la première (sachant qu’elles ont la même priorité) ?
  
  Ben on s'en fiche non ? Puisque le résultat sera le même ?
  
  Vous avez raison, l’ordre des opérations n’a ici aucune influence sur la valeur de l’expression. Cependant, il est des cas où cela peut poser problème. Prenez l’expression A = B = C, comment procède-t-on ?
  — Comme ceci : (A = (B = C)) …
  — … ou comme cela : ((A = B) = C) (ce qui est invalide en C) ?
  C'est ici que l’associativité intervient, en déterminant un sens de lecture. Pour l’opérateur =, l’associativité est de droite à gauche, donc on lit l’expression de la droite vers la gauche ; on rentre donc dans le premier cas. L'expression pourrait être reformulée comme suit : A = (B = C).
  
  Évidemment, il y a deux associativités possibles : de la gauche vers la droite (left to right, ltr) ou de la droite vers la gauche (right to left, rtl).
  

Trêve de bavardages, voici enfin le tableau tant attendu !

Les opérateurs du langage C : priorité, associativité et arité

Catégories d'opérateurs	Opérateurs	Assoc.	Arité
appel de fonction, indiçage, membre de structure, membre de structure pointée	( )	[ ]	.	->	-- 1	++ 1	ltr →	2 (1 pour ++ et --)
opérateurs unaires	(Type)	sizeof	_Alignof 2	*	&	!	~	-	+	-- 1	++ 1	rtl ←	1
multiplication, division, modulo	*	/	%	ltr →	2
addition, soustraction	+	-
décalage binaire	<<	>>
comparaison	<	<=	>=	>
==	!=
opérations binaires	&
^
|
opérations logiques	&&
||
opérateur conditionnel	? :	rtl ←	3
affectation	=	+=	-=	*=	/=	%=	<<=	>>=	&=	^=	|=	2
virgule	, 3	ltr →

Remarques :
¹ Il existe en fait deux opérateurs d’incrémentation et deux de décrémentation : les opérateurs postfixés (i--, i++) mais aussi les opérateurs préfixés (--i, ++i) qui sont moins connus des débutants (voir l’entrée [8][12] de cette FAQ). Les postfixés sont prioritaires sur les préfixés et ont une associativité contraire.
² L’opérateur _Alignof a été introduit en C11.
³ L’opérateur virgule (,) est très méconnu des débutants.


Cette page très complète du Wikipedia anglais apporte plus de détail. Elle présente tous les opérateurs du C et du C++, en indiquant s’ils sont surchargeables et comment, ainsi que leur priorité et leur associativité.

Citation : Maëlan

Conclusion : les champs de bits sont sympathiques et parfois bien pratiques, mais si vous visez la portabilité, mieux vaut les oublier. Si vous avez vraiment besoin de condenser vos données, utilisez manuellement les opérations binaires (&, |, ^).

Citation : Maëlan

Je ne sais pas. J’avais trouvé que la remarque était intéressante quand même, et que des C++istes pourraient peut-être lire quand même cette FAQ, mais c’est vrai que ça alourdit l’entrée. Peut-être avec un <secret>?