Les plus utiles faite C-macros (dans GCC, aussi C99)?

Ce C macro est à votre avis est le plus utile? J'ai trouvé le suivant, que j'utilise pour faire du vecteur de l'arithmétique dans C:

#define v3_op_v3(x, op, y, z) {z[0]=x[0] op y[0]; \
                               z[1]=x[1] op y[1]; \
                               z[2]=x[2] op y[2];}

Il fonctionne comme ça:

v3_op_v3(vectorA, +, vectorB, vectorC);
v3_op_v3(vectorE, *, vectorF, vectorJ);
...

Et vous n'êtes pas la mise en œuvre de la norme formes de vecteur de multiplication ici (pas de produit scalaire, produit vectoriel, ni tenseur de produit).
Composant-sage de multiplication a ses utilise, mais les dimensions de la limite imposée par la macro rend-il pas utile.
Ceci est destiné à être utilisé dans les zones où la limite dimensionnelle est strictement imposée par la nature même de la zone d'application. Comme dans les graphiques 3D, par exemple.
Mais, supposons que le nombre de dimensions dans l'univers change, le code de rupture - c'est le genre de vision à court terme qui ont conduit au problème Y2K.
Ouais... comme cette célèbre citation de Xerox manuel. L'un des avantages de déclarer PI comme une constante nommée, c'est qu'il vous permet de modifier le code dans le cas où la valeur de Pi changements.
Produits vectoriels? Avez-vous oublié C est trop?
De référence pour cette citation de Xerox FORTRAN manuel concernant les pi: en.wikiquote.org/wiki/Fortran

InformationsquelleAutor psihodelia | 2009-11-20

c c-preprocessor c99 macros

13

pour chaque boucle en C99:
```
#define foreach(item, array) \
    for(int keep=1, \
            count=0,\
            size=sizeof (array)/sizeof *(array); \
        keep && count != size; \
        keep = !keep, count++) \
      for(item = (array)+count; keep; keep = !keep)

int main() {
  int a[] = { 1, 2, 3 };
  int sum = 0;
  foreach(int const* c, a)
    sum += *c;
  printf("sum = %d\n", sum);

  //multi-dim array
  int a1[][2] = { { 1, 2 }, { 3, 4 } };
  foreach(int (*c1)[2], a1)
    foreach(int *c2, *c1) 
      printf("c2 = %d\n", *c2);
}
```
- C'est tellement facile d'utilisation abusive lorsque votre tableau soudainement devient allouées sur la pile...
- C. tout aussi facile d'utilisation abusive, le manuel sizeof-avec-forloop façon. Je soupçonne un mieux à double contrôle de toutes les actions dans C 🙂
- Oui, mon commentaire a été réalisé à l'idiome, pas pour la macro.
- Quel est le but de la keep variable, et pourquoi ne foreach étendre à un imbriquée for boucle?
- le but est de faire break travail (et mon code a été brisé. J'ai pensé que j'ai copié à partir d'une réponse différente de moi, mais apparemment, je n'étais pas assez réveillé :p. J'ai corrigé, merci de vérifier)
InformationsquelleAutor Johannes Schaub - litb
34
```
#define IMPLIES(x, y) (!(x) || (y))

#define COMPARE(x, y) (((x) > (y)) - ((x) < (y)))
#define SIGN(x) COMPARE(x, 0)

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))

#define SWAP(x, y, T) do { T tmp = (x); (x) = (y); (y) = tmp; } while(0)
#define SORT2(a, b, T) do { if ((a) > (b)) SWAP((a), (b), T); } while (0)

#define SET(d, n, v) do{ size_t i_, n_; for (n_ = (n), i_ = 0; n_ > 0; --n_, ++i_) (d)[i_] = (v); } while(0)
#define ZERO(d, n) SET(d, n, 0)
```
Et, bien sûr, diverses MIN, MAX, ABS, etc.

Remarque, d'ailleurs, qu'aucun des ci-dessus peut être mis en œuvre par une fonction en C.

P. S. j'aurais sans doute la-dessus IMPLIES macro comme l'un des plus utiles. Son but principal est de faciliter l'écriture de plus élégant et lisible affirmations, comme dans
```
void foo(int array[], int n) {
  assert(IMPLIES(n > 0, array != NULL));
  ...
```
- très joli, mais je ne peux toujours pas voter, désolé 🙁
- Votre macro-fu est impressionnant (vous parenthesize correctement et connaître les do...while(0) technique), mais il y a encore de multiples problèmes liés à l'évaluation que vous avez vraiment ne peut pas réparer.
- Thornley: "Plusieurs d'évaluation" avec des macros est également ce qui nous donne "évaluation différée". C'est un problème car c'est une fonctionnalité. Il suffit d'apprendre à l'utiliser correctement. Dire que le risque de "multiples d'évaluation" signifie en quelque sorte que l'on ne doit pas utiliser les macros, c'est exactement la même chose que de dire que l'on ne doit pas utiliser l'opérateur de division parce qu'il y a un risque de diviser par zéro.
- Pas besoin de temp-var lors de la permutation des entiers: #define SWAPINT(x, y) do { (x) ^= (y); (y) ^= (x); (x) ^= (y); } while(0)
- il n'y a pas besoin, mais votre façon signifie que les personnes qui veulent faire SWAPINT(*xp, *yp) maintenant besoin de vérifier xp != yp premier. Ces jours-ci je ne vois pas beaucoup de point en ajoutant un peu maladroite cas de bord afin de (peut-être) sauver un registre et/ou 4 octets de la pile.
- Non, je ne pouvais pas. Faire une recherche sur elle, c'est un truc et une question populaire. Par exemple, pensez à ce qui va arriver à if (condition) SWAP(a, b, int); else /* something */; avec ma version et avec les vôtres.
- imparfait analogie. Il n'y a pas d'opérateurs que regard comme la division opérateurs encore provoquer une erreur lors de la division par un ou deux. Cela dit, je n'ai rien contre les macros et les IMPLIES est vraiment sympa.
- Nice, aimer "IMPLIQUE" le plus 🙂
- Je suis très en retard pour ce parti, mais qu'est-DÉFINIR et ZÉRO n'?
- simplement assigne la valeur donnée v à tous n éléments du tableau d. ZERO utilise SET d'accorder de la valeur 0 à tous n éléments du tableau d.
- Je suis curieux, pourquoi ne pas l'appeler ARRAY_SET et ARRAY_ZERO pour être cohérent avec ARRAY_SIZE? Quand j'ai vu SET, j'ai été en quelque sorte d'attendre que peut-être un peu spécifique à une valeur ou quelque chose.
- Lehman: Les noms sont juste "dépouillé" versions de certains de la vie réelle de code. Bien entendu, en prenant sur ces mots génériques comme SET et ZERO avec une macro n'est pas une bonne idée en tout cas. Mais à l'adresse de votre point de vue: le ci-dessus ARRAY_SIZE macro est destiné à être utilisé avec les tableaux uniquement (pas avec les pointeurs), tandis que SET et ZERO ne sont pas liés à des tableaux, ils peuvent travailler avec des pointeurs ainsi. Pour continuer à suivre cette convention, le nom ARRAY_SET dans ce contexte aurait plus de sens avec la définition suivante: #define ARRAY_SET(a) SET(a, ARRAY_SIZE(a)). De même pour ARRAY_ZERO.
- Je ne suis pas sûr de comprendre IMPLIES quelqu'un peut-il m'expliquer? Ce qui est fait avec elle? Pourquoi voudriez-vous affirmer que la matrice a 0 ou négatif de la longueur OU elle n'est pas NULLE? (assert(!(n > 0) || array != NULL))
- Cette condition a effectivement dit: "si la longueur du tableau n est positif, alors array pointeur ne peut pas être null. Dans tous les autres cas, nous ne se soucient pas ce que array est".
- Je vois. Mais pourquoi voudriez-vous l'affirmation de réussir si n négatif? Pourquoi ne pas assert(n > 0 && array != NULL)? Je ne peux pas penser quand il serait OK pour avoir une longueur négative. Peut-être que ce n'était pas le meilleur exemple pour démontrer IMPLIES?
- Eh bien, je veux permettre à n == 0 (c'est à dire "pas de tableau passé"). Je ne veux pas vraiment à permettre n < 0, mais par souci de simplicité, je l'ai traitée n < 0 de la même manière que n == 0 (c'est à dire de négatif n signifie aussi "no array passed"). In my code I'd actually make a point of using an *unsigned* type for n, which would eliminate the issue of negative n` de la considération. À la signature du type le plus approprié de l'assertion serait assert(n >= 0 && IMPLIES(n > 0, array != NULL)).
- A noter encore que je ne veux pas exiger n > 0 ici. Je veux permettre à n == 0 ainsi. Et si n == 0, je ne veux pas imposer des exigences sur array. C'est ce que IMPLIES m'aide à atteindre.
InformationsquelleAutor AnT
22

Le point clé avec C macros est de les utiliser correctement. Dans mon esprit il y a trois catégories (sans tenir compte de l'aide juste pour donner des noms descriptifs pour les constantes)
1. Comme une abréviation pour un morceau de codes l'on ne veut pas répéter
2. De fournir une fonction d'utilisation
3. Modifier la structure du langage C (apparemment)
Dans le premier cas, la macro s'vivre dans votre programme (généralement un fichier) de sorte que vous pouvez utiliser des macros comme celui que vous avez posté, qui n'est pas protégé contre la double évaluation des paramètres et utilise {...}; (potentiellement dangereux!).

Dans le second cas (et encore plus dans le troisième), vous devez être extrêmement attention à ce que vos macros se comportent correctement, comme si elles étaient réelles C constructions.

La macro que vous avez posté de GCC (min et max) est un exemple de cela, ils utilisent les variables globales _a et _b pour éviter le risque de double évaluation (comme dans max(x++,y++)) (bien, ils utilisent des extensions de GCC, mais le concept est le même).

J'aime utiliser des macros où il contribue à rendre les choses plus claires, mais elles sont un outil pointu! Probablement que c'est ce qui leur a donné une mauvaise réputation, je pense qu'ils sont un outil très utile et C aurait été beaucoup plus pauvres si ils n'étaient pas présents.

Je vois d'autres ont fourni des exemples de point 2 (macros comme des fonctions), permettez-moi de donner un exemple de création d'un nouveau C construction: la machine à états Finis. (J'ai déjà posté ceci sur mais je n'arrive pas à être en mesure de le trouver)
```
 #define FSM            for(;;)
 #define STATE(x)       x##_s 
 #define NEXTSTATE(x)   goto x##_s
```
que vous utilisez cette manière:
```
 FSM {
    STATE(s1):
      ... do stuff ...
      NEXTSTATE(s2);

    STATE(s2):
      ... do stuff ...
      if (k<0) NEXTSTATE(s2); 
      /* fallthrough as the switch() cases */

    STATE(s3):
      ... final stuff ...
      break;  /* Exit from the FSM */
 } 
```
Vous pouvez ajouter une variation sur ce thème pour vous faire une idée de la FSM dont vous avez besoin.

Quelqu'un peut ne pas aimer cet exemple, mais je trouve qu'il est parfait pour montrer comment de simples macros peuvent rendre votre code plus lisible et expressive.
- ressemble plus à VHDL ou alors 🙂
- vous êtes une mauvaise personne mal lol
InformationsquelleAutor Remo.D
11

Si vous avez besoin de définir des données à de multiples reprises dans des contextes différents, les macros peuvent vous aider à éviter d'avoir à réinscrire la même chose plusieurs fois.

Par exemple, disons que vous souhaitez définir une énumération de couleurs et un enum-à-fonction de chaîne, plutôt que de lister toutes les couleurs à deux fois, vous pouvez créer un fichier de couleurs (couleurs.def):
```
c(red)
c(blue)
c(green)
c(yellow)
c(brown)
```
Vous pouvez maintenant c ton fichier, vous pouvez définir votre enum et de votre chaîne de fonctions de conversion:
```
enum {
#define c(color) color,
# include "colors.def"
#undef c
};

const char *
color_to_string(enum color col)
{
    static const char *colors[] = {
#define c(color) #color,
# include "colors.def"
#undef c
    };
    return (colors[col]);
};
```
- Ceux-ci sont appelés X-macros. en.wikibooks.org/wiki/C_Programming/Preprocessor#X-Macros
InformationsquelleAutor srparish
7
```
#if defined NDEBUG
    #define TRACE( format, ... )
#else
    #define TRACE( format, ... )   printf( "%s::%s(%d)" format, __FILE__, __FUNCTION__,  __LINE__, __VA_ARGS__ )
#endif
```
Noter que l'absence d'une virgule entre "%s::%s(%d)" et format est délibéré. Il affiche une chaîne formatée avec l'emplacement de la source précédée. Je travaille dans les systèmes temps-réel embarqués si souvent j'ai également inclure un horodateur dans la sortie ainsi.
- Ne pas le NDEBUG un être #define TRACE (format, ...) ((void)0) à éviter les pièges comme if(cond) TRACE(...) ?
- Qu'est-ce que le "piège"? Si vous ne l'avez pas, placez un point-virgule après l'appel de macro, il est probablement mal, en tout cas - if(x) TRACE("y = %d", y ); permettrait de résoudre à if(x); qui n'aura aucun effet.
- Oups... j'ai été assez sûr qu'à un moment, j'ai utilisé un compilateur pour ce qui ; n'était pas une instruction valide, mais ce n'est pas un problème pour GCC. affirmer.h semble toujours utiliser #define assert(ignore)((void) 0) bien.
InformationsquelleAutor Clifford

Boucle Foreach pour GCC, spécifiquement C99 avec GNU Extensions. Fonctionne avec des chaînes et des tableaux. Des tableaux alloués dynamiquement peuvent être utilisées par casting pour un pointeur sur un tableau, et ensuite déréférencement les.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define FOREACH_COMP(INDEX, ARRAY, ARRAY_TYPE, SIZE) \
__extension__ \
({ \
bool ret = 0; \
if (__builtin_types_compatible_p (const char*, ARRAY_TYPE)) \
ret = INDEX < strlen ((const char*)ARRAY); \
else \
ret = INDEX < SIZE; \
ret; \
})
#define FOREACH_ELEM(INDEX, ARRAY, TYPE) \
__extension__ \
({ \
TYPE *tmp_array_ = ARRAY; \
&tmp_array_[INDEX]; \
})
#define FOREACH(VAR, ARRAY) \
for (void *array_ = (void*)(ARRAY); array_; array_ = 0) \
for (size_t i_ = 0; i_ && array_ && FOREACH_COMP (i_, array_, \
__typeof__ (ARRAY), \
sizeof (ARRAY) / sizeof ((ARRAY)[0])); \
i_++) \
for (bool b_ = 1; b_; (b_) ? array_ = 0 : 0, b_ = 0) \
for (VAR = FOREACH_ELEM (i_, array_, __typeof__ ((ARRAY)[0])); b_; b_ = 0)
/* example's */
int
main (int argc, char **argv)
{
int array[10];
/* initialize the array */
int i = 0;
FOREACH (int *x, array)
{
*x = i;
++i;
}
char *str = "hello, world!";
FOREACH (char *c, str)
printf ("%c\n", *c);
/* Use a cast for dynamically allocated arrays */
int *dynamic = malloc (sizeof (int) * 10);
for (int i = 0; i < 10; i++)
dynamic[i] = i;
FOREACH (int *i, *(int(*)[10])(dynamic))
printf ("%d\n", *i);
return EXIT_SUCCESS;
}

Ce code a été testé pour fonctionner avec GCC, la cour et le Bruit sur GNU/Linux.

Expressions Lambda (GCC seulement)

#define lambda(return_type, ...) \
__extension__ \
({ \
return_type __fn__ __VA_ARGS__ \
__fn__; \
})
int
main (int argc, char **argv)
{
int (*max) (int, int) = 
lambda (int, (int x, int y) { return x > y ? x : y; });
return max (1, 2);
}

InformationsquelleAutor Joe D

#define COLUMNS(S,E) [ (E) - (S) + 1 ]
struct 
{
char firstName COLUMNS ( 1, 20);
char LastName  COLUMNS (21, 40);
char ssn       COLUMNS (41, 49);
}

Vous éviter quelques erreurs de comptage

merci, très utile en fait! (vous avez oublié les types dans votre exemple)

InformationsquelleAutor EvilTeach

5

Quelqu'un d'autre a mentionné container_of(), mais ne pas fournir une explication pour ce très pratique en macro. Disons que vous avez une structure qui ressemble à ceci:
```
struct thing {
int a;
int b;
};
```
Maintenant, si nous avons un pointeur vers b, nous pouvons utiliser container_of() pour obtenir un pointeur vers chose dans un type de coffre-fort de la mode:
```
int *bp = ...;
struct thing *t = container_of(bp, struct thing, b);
```
Ceci est utile dans la création de structures de données abstraites. Par exemple, plutôt que de prendre l'approche de la file d'attente.h faut pour créer des choses comme SLIST (des tonnes de fou macros pour chaque opération), vous pouvez maintenant écrire un slist de mise en œuvre qui ressemble à quelque chose comme ceci:
```
struct slist_el {
struct slist_el *next;
};
struct slist_head {
struct slist_el *first;
};
void
slist_insert_head(struct slist_head *head, struct slist_el *el)
{
el->next = head->first;
head->first = el;
}
struct slist_el
slist_pop_head(struct slist_head *head)
{
struct slist_el *el;
if (head->first == NULL)
return NULL;
el = head->first;
head->first = el->next;
return (el);   
}
```
Qui n'est pas fou le code de macro. Il donnera de bons compilateur de ligne de chiffres sur les erreurs et les œuvres de nice avec le débogueur. Il est aussi assez typesafe, sauf pour les cas où les structures d'utiliser plusieurs types (par exemple, si nous avons permis struct couleur dans l'exemple ci-dessous pour être sur plus de listes liées que juste le couleurs un).

Les utilisateurs peuvent maintenant utiliser votre bibliothèque comme ceci:
```
struct colors {
int r;
int g;
int b;
struct slist_el colors;
};
struct *color = malloc(sizeof(struct person));
color->r = 255;
color->g = 0;
color->b = 0;
slist_insert_head(color_stack, &color->colors);
...
el = slist_pop_head(color_stack);
color = el == NULL ? NULL : container_of(el, struct color, colors);
```
InformationsquelleAutor srparish
4

C'est à partir du noyau linux (gcc spécifique):
```
#define container_of(ptr, type, member) ({                  \
const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
(type *)( (char *)__mptr - offsetof(type,member) ); })
```
Un autre manquant d'autres réponses:
```
#define LSB(x) ((x) ^ ((x) - 1) & (x))   //least significant bit
```
- Le nom de la dernière macro est assez déroutant. LSB évoque (x) & 1.
- Ce dernier devrait être LSSB -- least significant bit
- Ou le LSD - chiffre le Moins significatif, mais j'ai peur que peut avoir le négatif conotations...
InformationsquelleAutor Alexandru
2

J'aime aussi celui-ci:
```
#define COMPARE_FLOATS(a,b,epsilon) (fabs(a - b) <= epsilon * fabs(a))
```
Et comment vous les macros-haters faire juste à virgule flottante comparaisons?
- Pourquoi voudriez-vous utiliser une macro au lieu d'une fonction pour ça? Et ce qui se passe lorsque vous utilisez la " COMPARE_FLOATS(a,b,-x,eps)'?
- Pour ne pas mentionner ce ne mal si a est 0.0.
- "comment vous macros-haters faire juste à virgule flottante comparaisons" statique de la fonction en ligne.
- Il n'y a pas une telle chose comme "macro hater". Chaque fois que vous voyez un "macro" chauffe, il est en réalité un débutant qui essaie de se présenter comme plus mature programmeur qu'il est vraiment en parroting ce qu'il pense des sons comme "mature" maxima.
- C'est très bien si vous voulez les comparer de manière incorrecte. Voici comment le faire: cygnus-software.com/papers/comparingfloats/comparingfloats.htm
- Étant donné que je suis une macro hater, pourriez-vous estimer combien d'années j'ai travaillé professionnellement dans le C et le C++, et le nombre de cours que j'ai enseigné au niveau Universitaire sur la programmation en C?
- Je déteste les macros trop. Je déteste aussi les tondeuses à gazon - en général, je reconnais la nécessité d'une plus courte de l'herbe, je n'ai juste pas profiter du processus de l'aide de l'un pour obtenir l'autre. J'ai utilisé les macros dans une autre langue, qui étaient beaucoup plus riches (par exemple, vous pourriez boucle sans recourir à un appel récursif à inclure), et pourtant, qui étaient également plus facile à utiliser correctement que C macros.
- Oui, je suppose que je me dois de préciser. Je déteste C macros. J'aime Lisp macros.
- Certainement prouve vos diplômes et attestations 😉
- Thornley: Est-il pertinent? Une grand-mère qui était au volant de sa maison à son favori épicerie pour les 40 ans techniquement a 40 ans d'expérience de conduite. Ne qui font d'elle un bon conducteur? Les bons programmeurs jamais la haine rien, puisque tout, absolument tout a son temps et lieu.
- en fait c'est pertinent. Que grand-mère n'est pas un "débutant". Vous avez affirmé que tous les macro-hater est un débutant, non pas que tous les macro-hater est un mauvais programmeur. Mais même en faisant semblant de vous l'avais dit "non-bien" en premier lieu, c'est absurde. Reconnaissant la nécessité d'une technique, et de l'utiliser correctement, n'est pas identique à l'aimer, et vous pouvez toujours être agacé, il n'y a pas quelque chose de mieux. De plus, s'il était vrai que les bons programmeurs crois que tout a son temps et de place, alors pas de bon programmeur aurait jamais déprécier ou de supprimer tout élément dans une nouvelle version.
- Mais de toute façon, je pense que cela a maintenant complètement descendus à la "pas de true Scotsman" argument. Andrey dit, "pas bon programmeur n'est pas d'accord avec moi". David dit: "je suis un bon programmeur, et je suis en désaccord avec vous". Andrey dit, "mais si vous êtes en désaccord avec moi, alors vous ne pouvez pas éventuellement être un bon programmeur".
- Caractéristiques n'obtenez pas obsolète de haine pure. Aucun programmeur ne serait jamais déprécier une fonctionnalité jusqu'à ce qu'un remplacement adéquat fonctionnalité est implémentée.
- Mais la raison pour laquelle vous développer un remplacement pourrait bien être que vous détestez que l'original.
- J'adore les macros, mais je fais de mon virgule flottante comparaisons de la manière que dieu a prévu -- stricte égalité.
- Btw, noté "mauvais programmeur" Jon Skeet déteste le "lock" déclaration en C# ;-p
- Désolé, j'ai oublié le lien: stackoverflow.com/questions/282329/...
- Pas de véritable "no true Scotsman" argument serait descendre à ce niveau
- assurez-vous de ne pas écrire des logiciels pour la NASA.
- Je préfère de beaucoup que les ingénieurs de la NASA savent ce qu'ils font et l'utilisation stricte de l'égalité des comparaisons lorsque approprié qu'ils ne comprennent pas à virgule flottante et se jettent aveuglément epsilons autour sans réellement comprendre le problème parce que certains gars sur internet dit. Il y a des situations qui se rapprochent de comparaisons sont appropriées, et il y a des situations dans lesquelles des comparaisons exactes sont appropriées. À cause du travail que je fais (bibliothèque de mathématiques de développement), j'arrive à voir beaucoup plus de celui-ci.
- de ce que j'avais compris à partir d'Unités de police constituées, ils perdent de précision dans le déplacement etc et ce qui devrait, en théorie, le rendement, la même valeur qu'une autre expression, peut en fin de compte arriver à être légèrement différentes. Peut-être que vous le savez très bien tous les détails des opérations en virgule flottante, mais ce n'est pas le cas avec la plupart des programmeurs. Votre commentaire pourrait facilement induire en erreur un programmeur nouveau dans cette région. Compte tenu de la nature de ce site, je dirais que c'est pas si bon.
InformationsquelleAutor psihodelia
2

Juste le standard:
```
#define LENGTH(array) (sizeof(array) / sizeof (array[0]))
#define QUOTE(name) #name
#define STR(name) QUOTE(name)
```
mais il n'y a rien de trop spiffy là.
- En passant: quelqu'un a posté une LONGUEUR de macro de Google qui serait la cause d'une erreur de compilation si passé un pointeur, mais je n'ai pas été en mesure de le retrouver. Personne ne sait le macro et avoir un lien vers la réponse (ou une autre page), qui se montre?
- Celui-ci travaille pour des tableaux unidimensionnels, mais vous avez besoin de la passer à l'élément de type: #define REQUIRE_ARRAY(T, X) (void)(sizeof (((char(*)(T(*)[]))0)(&(X))))
- Les ouvrages suivants, en C99 aussi pour les dimensions supérieur à 1. Vous devez appeler REQUIRE_ARRAY2 pour un tableau à 2 dimensions, par exemple: #define REQUIRE_ARRAY2(T, X) (void)(sizeof (((char(*)(T(*)[*][*]))0)(&(X))))
- Très en retard à la fête, mais je crois #define IS_ARRAY(a) ((void *)&a == (void *)a) fonctionne comme un exécution de test pour savoir si quelque chose est un tableau ou un pointeur (sauf si le pointeur pointe vers lui-même, ce qui peut se produire dans le cadre d'une circulaire à structure liée, mais qui est un peu rare).
- La partie ne se termine jamais. Le Google LONGUEUR de la macro peut avoir été la seule posté par Michael Burr en réponse à "Commune de la longueur du tableau de macro pour le C?". Notez que ce n'est pas un test de savoir si quelque chose est un tableau, mais une macro que les résultats de la longueur d'un tableau ou d'une erreur pour d'autres types.
InformationsquelleAutor outis
2
```
#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
```
Trouver la plus proche de 32 bits entier non signé qui est plus grand que x. Je l'utilise pour le double de la taille des tableaux (c'est à dire la ligne des hautes eaux).
- Ne serait-il pas plus simple et plus rapide à utiliser __builtin_clz et un seul quart de travail?
InformationsquelleAutor user172818
1

Pack octets,mots,dword en mots,dword et qwords:
```
#define ULONGLONG unsigned __int64
#define MAKEWORD(h,l) ((unsigned short) ((h) << 8)) | (l)
#define MAKEDWORD(h,l) ((DWORD) ((h) << 16)) | (l)
#define MAKEQWORD(h,l) ((ULONGLONG)((h) << 32)) | (l) 
```
Parenthesizing arguments, il est toujours une bonne pratique pour éviter les effets secondaires sur l'expansion.
- Vous devriez typedef ULONGLONG: typedef unsigned __int64 ULONGLONG;
- N'est-ce pas MAKEQWORD mal? Jette de la h à ULONGLONG avant de passer, pas après.
InformationsquelleAutor Hernán
0

aussi multi-type Minimum et Maximum comme ça
```
//NOTE: GCC extension !
#define max(a,b) ({typeof (a) _a=(a); typeof (b) _b=(b); _a > _b ? _a:_b; })
#define min(a,b) ({typeof (a) _a=(a); typeof (b) _b=(b); _a < _b ? _a:_b; })
```
- C'est tellement court, c'est effrayant. Aussi, c'est un parfait exemple de pourquoi pas pour l'utilisation de macros. (parce que les arguments sont (sous certaines conditions), on a évalué plusieurs fois)
- ou (n'ont pas eu assez de café), vous travaillez avec des objets copiés
- Je pense que, il y avait de la gcc extension min/max. Quelque chose comme a >? b
- Si vous allez travailler avec des objets copiés, vous pouvez aussi bien utiliser des fonctions. Ce n'est pas quelque chose qui peut être fait avec C macros.
- Hein? Le code ci-dessus utilise GCC extensions spécialement pour éviter de multiples évaluations. Il n'y a pas plusieurs evaluatuion ci-dessus.
- Ceux qui ont g++ et extensions ont été dépréciées depuis la gcc 4.0. gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/...
- aussi trois paramètre de version, utile parfois: #define max(a,b,c) (a) > (b) ? (a) > (c) ? (a) : (c)) : ((b)>(c) ? (b) : (c))
- et ce qui est avec quatre paramètres? J'irais pour max(max(a, b), c) au lieu
- c'est également ok, mais j'utilise C++ inlines et modèles, de toute façon 😉
InformationsquelleAutor psihodelia
0

Vérifier si une variable point x n'est Pas Un Nombre:
```
#define ISNAN(x) ((x) != (x))
```
- encore une fois, pourquoi ne pas mettre en œuvre ce qu'un (inline) fonction?
- parce que le C99 inline spécification des fonctions n'est pas pris en charge par de nombreux compilateurs.
- il est très largement pris en charge, il n'est pas toujours appelé inline.
- si vous êtes à l'aide de fonctions C99 (inline), il suffit d'utiliser la C99 isnan( ) macro définie dans <math.h>.
InformationsquelleAutor psihodelia
0

Un (de très peu) que j'utilise régulièrement est une macro pour déclarer un argument ou d'une variable inutilisée. Le plus compatible avec la solution ce n'est (à mon humble avis) varie en fonction du compilateur.
- pouvez-vous nous montrer un exemple typique?
InformationsquelleAutor justin
-1

C'est génial:
```
#define NEW(type, n) ( (type *) malloc(1 + (n) * sizeof(type)) )
```
Et je l'utilise comme:
```
object = NEW(object_type, 1);
```
- C'est quoi l' 1+ de l'allocation d'un octet supplémentaire pour chaque allocation?
- Et pourquoi le casting? N'utilisez jamais que jeté sur le résultat de malloc() ou liées à la fonction. Il faut du temps pour type, et la seule fois où il n'est rien si vous avez oublié de #include <stdlib.h>. Si je fais ça, je préfère avoir le diagnostic que d'avoir des trucs probablement continuer à travailler.
- malloc dans une macro? êtes-vous sérieux? Personne ne saura jamais d'où cette fuite de mémoire sont venus.
- La macro nommée NEW—semble assez clair pour moi, il peut allouer de la mémoire. Aussi, le casting est nécessaire pour le C++, qui ne sera pas convertir implicitement un void * vers un autre type.
- Si vous écrivez en C++: NE le faites PAS! Utilisation new au lieu de cela, et de ne jamais utiliser les macros de ce genre.
- Ce défaut de travailler en C++ est sans doute une caractéristique. Il vous dit que vous avez tort exécuter le compilateur. Si vous voulez vraiment pour compiler du C avec un compilateur C++, vous pouvez toujours définir les différentes versions de la macro selon qu' __cplusplus est réglé. En utilisant cette macro à tous, véritable C++ est discutable, et l'appeler de NOUVEAU en C++ quand il n'a rien à voir avec new n'est probablement pas un bon plan.
- Pourquoi êtes-vous en ajoutant 1 après multipliant n par la taille de ce type? Avez-vous peur que quelqu'un pourrait passer n de zéro? Que faire si ils passent une valeur négative?
InformationsquelleAutor psihodelia
-1

Le VRAI et le FAUX semble être populaire.
- Et mal utilisé. C'est dommage que C ne dispose pas d'un réel de type booléen, comme C++ ou Java.
- C99 a un type bool, stdbool.h
- Je vois if (var == TRUE) trop souvent et de refuser de les utiliser.
InformationsquelleAutor T.E.D.

Vous devez vous connecter pour publier un commentaire.