Fonctionnalités cachées de C

Je sais qu'il existe une norme derrière toutes les implémentations du compilateur C, il ne devrait donc pas y avoir de fonctionnalités cachées. Malgré cela, je suis sûr que tous les développeurs C ont des astuces cachées / secrètes qu'ils utilisent tout le temps.

Pointeurs de fonction. Vous pouvez utiliser une table de pointeurs de fonction pour implémenter, par exemple, des interpréteurs de code à thread indirect rapide (FORTH) ou des répartiteurs de code d'octet, ou pour simuler des méthodes virtuelles de type OO.

Ensuite, il y a des gemmes cachées dans la bibliothèque standard, telles que qsort (), bsearch (), strpbrk (), strcspn () [les deux derniers étant utiles pour implémenter un remplacement strtok ()].

Un défaut de C est que le débordement arithmétique signé est un comportement indéfini (UB). Ainsi, chaque fois que vous voyez une expression telle que x + y, tous deux signés ints, cela peut potentiellement déborder et provoquer UB.

Plus une astuce du compilateur GCC, mais vous pouvez donner des indices d'indication de branche au compilateur (commun dans le noyau Linux)

#define likely(x)       __builtin_expect((x),1)
#define unlikely(x)     __builtin_expect((x),0)

voir: http://kerneltrap.org/node/4705

Ce que j'aime à ce sujet, c'est que cela ajoute également une certaine expressivité à certaines fonctions.

void foo(int arg)
{
     if (unlikely(arg == 0)) {
           do_this();
           return;
     }
     do_that();
     ...
}

int8_t
int16_t
int32_t
uint8_t
uint16_t
uint32_t

Il s'agit d'un élément facultatif dans la norme, mais il doit s'agir d'une fonctionnalité masquée, car les gens les redéfinissent constamment. Une base de code sur laquelle j'ai travaillé (et je le fais encore, pour l'instant) a plusieurs redéfinitions, toutes avec des identifiants différents. La plupart du temps, c'est avec des macros de préprocesseur:

#define INT16 short
#define INT32  long

Etc. Cela me donne envie de m'arracher les cheveux. Utilisez simplement les typedefs entiers standards!

L'opérateur virgule n'est pas largement utilisé. Il peut certes être abusé, mais il peut aussi être très utile. Cette utilisation est la plus courante:

for (int i=0; i<10; i++, doSomethingElse())
{
  /* whatever */
}

Mais vous pouvez utiliser cet opérateur n'importe où. Observer:

int j = (printf("Assigning variable j\n"), getValueFromSomewhere());

Chaque instruction est évaluée, mais la valeur de l'expression sera celle de la dernière instruction évaluée.

initialisation de la structure à zéro

struct mystruct a = {0};

cela mettra à zéro tous les éléments de structure.

Constantes multi-caractères:

int x = 'ABCD';

Cela définit xà 0x41424344(ou 0x44434241, selon l'architecture).

EDIT: Cette technique n'est pas portable, surtout si vous sérialisez l'int. Cependant, il peut être extrêmement utile de créer des énumérations auto-documentées. par exemple

enum state {
    stopped = 'STOP',
    running = 'RUN!',
    waiting = 'WAIT',
};

Cela rend les choses beaucoup plus simples si vous regardez un vidage de la mémoire brute et que vous devez déterminer la valeur d'une énumération sans avoir à la rechercher.

Je n'ai jamais utilisé de champs de bits, mais ils sonnent bien pour les trucs à très bas niveau.

struct cat {
    unsigned int legs:3;  // 3 bits for legs (0-4 fit in 3 bits)
    unsigned int lives:4; // 4 bits for lives (0-9 fit in 4 bits)
    // ...
};

cat make_cat()
{
    cat kitty;
    kitty.legs = 4;
    kitty.lives = 9;
    return kitty;
}

Cela signifie que cela sizeof(cat)peut être aussi petit que sizeof(char).

Commentaires incorporés par Aaron et leppie , merci les gars.

C a une norme mais tous les compilateurs C ne sont pas entièrement compatibles (je n'ai pas encore vu de compilateur C99 entièrement conforme!).

Cela dit, les astuces que je préfère sont celles qui ne sont pas évidentes et portables sur toutes les plates-formes car elles reposent sur la sémantique C. Il s'agit généralement de macros ou d'arithmétique binaire.

Par exemple: permuter deux entiers non signés sans utiliser de variable temporaire:

...
a ^= b ; b ^= a; a ^=b;
...

ou "étendre C" pour représenter des machines à états finis comme:

FSM {
  STATE(x) {
    ...
    NEXTSTATE(y);
  }

  STATE(y) {
    ...
    if (x == 0) 
      NEXTSTATE(y);
    else 
      NEXTSTATE(x);
  }
}

cela peut être réalisé avec les macros suivantes:

#define FSM
#define STATE(x)      s_##x :
#define NEXTSTATE(x)  goto s_##x

En général, cependant, je n'aime pas les astuces qui sont intelligentes mais rendent le code inutilement compliqué à lire (comme l'exemple d'échange) et j'aime celles qui rendent le code plus clair et transmettent directement l'intention (comme l'exemple FSM) .

Structures entrelacées comme le dispositif de Duff :

strncpy(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
               } while (--n > 0);
    }
}

J'aime beaucoup les initialiseurs désignés, ajoutés dans C99 (et pris en charge dans gcc depuis longtemps):

#define FOO 16
#define BAR 3

myStructType_t myStuff[] = {
    [FOO] = { foo1, foo2, foo3 },
    [BAR] = { bar1, bar2, bar3 },
    ...

L'initialisation du tableau ne dépend plus de la position. Si vous modifiez les valeurs de FOO ou BAR, l'initialisation du tableau correspondra automatiquement à leur nouvelle valeur.

C99 a une super initialisation de structure dans n'importe quel ordre.

struct foo{
  int x;
  int y;
  char* name;
};

void main(){
  struct foo f = { .y = 23, .name = "awesome", .x = -38 };
}

les structures et tableaux anonymes sont mes préférés. (cf. http://www.run.montefiore.ulg.ac.be/~martin/resources/kung-f00.html )

setsockopt(yourSocket, SOL_SOCKET, SO_REUSEADDR, (int[]){1}, sizeof(int));

ou

void myFunction(type* values) {
    while(*values) x=*values++;
}
myFunction((type[]){val1,val2,val3,val4,0});

il peut même être utilisé pour instancier des listes chaînées ...

gcc a un certain nombre d'extensions au langage C que j'apprécie, qui peuvent être trouvées ici . Certains de mes favoris sont des attributs de fonction . Un exemple extrêmement utile est l'attribut format. Cela peut être utilisé si vous définissez une fonction personnalisée qui prend une chaîne de format printf. Si vous activez cet attribut de fonction, gcc vérifiera vos arguments pour s'assurer que votre chaîne de format et vos arguments correspondent et générera des avertissements ou des erreurs selon le cas.

int my_printf (void *my_object, const char *my_format, ...)
            __attribute__ ((format (printf, 2, 3)));

la fonction (cachée) qui m'a "choqué" quand j'ai vu pour la première fois concerne printf. cette fonctionnalité vous permet d'utiliser des variables pour formater les spécificateurs de format eux-mêmes. cherchez le code, vous verrez mieux:

#include <stdio.h>

int main() {
    int a = 3;
    float b = 6.412355;
    printf("%.*f\n",a,b);
    return 0;
}

le caractère * réalise cet effet.

Eh bien ... je pense que l'un des points forts du langage C est sa portabilité et sa standardité, donc chaque fois que je trouve un "truc caché" dans l'implémentation que j'utilise actuellement, j'essaye de ne pas l'utiliser car j'essaye de garder mon Code C aussi standard et portable que possible.

Assertions au moment de la compilation, comme déjà discuté ici .

//--- size of static_assertion array is negative if condition is not met
#define STATIC_ASSERT(condition) \
    typedef struct { \
        char static_assertion[condition ? 1 : -1]; \
    } static_assertion_t

//--- ensure structure fits in 
STATIC_ASSERT(sizeof(mystruct_t) <= 4096);

Concaténation de chaînes constante

J'ai été assez surpris de ne pas le voir déjà dans les réponses, car tous les compilateurs que je connais le supportent, mais de nombreux programmeurs semblent l'ignorer. Parfois, c'est vraiment pratique et pas seulement lors de l'écriture de macros.

Cas d'utilisation que j'ai dans mon code actuel: j'ai un #define PATH "/some/path/"dans un fichier de configuration (en fait, il est réglé par le makefile). Maintenant, je veux créer le chemin complet avec les noms de fichiers pour ouvrir les ressources. Cela va simplement à:

fd = open(PATH "/file", flags);

Au lieu de l'horrible, mais très commun:

char buffer[256];
snprintf(buffer, 256, "%s/file", PATH);
fd = open(buffer, flags);

Notez que la solution horrible commune est:

• trois fois plus longtemps
• beaucoup moins facile à lire
• beaucoup plus lent
• moins puissant lorsqu'il est défini sur une limite de taille de tampon arbitraire (mais vous devrez utiliser un code encore plus long pour éviter cela sans contaténation de chaînes constantes).
• utiliser plus d'espace de pile

Eh bien, je ne l'ai jamais utilisé, et je ne sais pas si je le recommanderais à qui que ce soit, mais je pense que cette question serait incomplète sans une mention de l'astuce de co-routine de Simon Tatham .

Lors de l'initialisation de tableaux ou d'énumérations, vous pouvez mettre une virgule après le dernier élément de la liste d'initialisation. par exemple:

int x[] = { 1, 2, 3, };

enum foo { bar, baz, boom, };

Cela a été fait pour que si vous générez du code automatiquement, vous n'ayez pas à vous soucier d'éliminer la dernière virgule.

L'affectation des structures est cool. Beaucoup de gens ne semblent pas se rendre compte que les structures sont aussi des valeurs et peuvent être attribuées, il n'est pas nécessaire d'utilisermemcpy() , lorsqu'une simple affectation fait l'affaire.

Par exemple, considérons une bibliothèque de graphiques 2D imaginaires, elle pourrait définir un type pour représenter une coordonnée d'écran (entière):

typedef struct {
   int x;
   int y;
} Point;

Maintenant, vous faites des choses qui peuvent sembler "incorrectes", comme écrire une fonction qui crée un point initialisé à partir des arguments de fonction, et le renvoie, comme ceci:

Point point_new(int x, int y)
{
  Point p;
  p.x = x;
  p.y = y;
  return p;
}

C'est sûr, tant (bien sûr) que la valeur de retour est copiée par valeur à l'aide de l'affectation de structure:

Point origin;
origin = point_new(0, 0);

De cette façon, vous pouvez écrire du code assez propre et orienté objet, le tout en C.

Indexation vectorielle étrange:

int v[100]; int index = 10; 
/* v[index] it's the same thing as index[v] */

Les compilateurs C implémentent l'une des nombreuses normes. Cependant, avoir une norme ne signifie pas que tous les aspects de la langue sont définis. L'appareil de Duff , par exemple, est une fonctionnalité `` cachée '' préférée qui est devenue si populaire que les compilateurs modernes ont un code de reconnaissance à usage spécial pour s'assurer que les techniques d'optimisation ne sabotent pas l'effet souhaité de ce modèle souvent utilisé.

En général, les fonctionnalités cachées ou les astuces de langage sont déconseillées car vous exécutez à la limite du (des) standard (s) C utilisé par votre compilateur. Beaucoup de ces astuces ne fonctionnent pas d'un compilateur à un autre, et souvent ces types de fonctionnalités échoueront d'une version d'une suite de compilateurs d'un fabricant donné à une autre version.

Diverses astuces qui ont cassé le code C incluent:

1. S'appuyant sur la façon dont le compilateur dispose les structures en mémoire.
2. Hypothèses sur l' endianité des entiers / flottants.
3. Hypothèses sur les ABI de fonction.
4. Hypothèses sur la direction de croissance des cadres.
5. Hypothèses sur l'ordre d'exécution dans les instructions.
6. Hypothèses sur l'ordre d'exécution des instructions dans les arguments de fonction.
7. Hypothèses sur la taille en bits ou la précision des types short, int, long, float et double.

D'autres problèmes et problèmes qui surviennent chaque fois que les programmeurs font des hypothèses sur les modèles d'exécution qui sont tous spécifiés dans la plupart des normes C comme un comportement «dépendant du compilateur».

Lorsque vous utilisez sscanf, vous pouvez utiliser% n pour savoir où vous devez continuer à lire:

sscanf ( string, "%d%n", &number, &length );
string += length;

Apparemment, vous ne pouvez pas ajouter une autre réponse, donc je vais en inclure une deuxième ici, vous pouvez utiliser "&&" et "||" comme conditionnels:

#include <stdio.h>
#include <stdlib.h>

int main()
{
   1 || puts("Hello\n");
   0 || puts("Hi\n");
   1 && puts("ROFL\n");
   0 && puts("LOL\n");

   exit( 0 );
}

Ce code affichera:

salut
ROFL

utiliser INT (3) pour définir le point d'arrêt au code est mon préféré de tous les temps

Ma fonction "cachée" préférée de C est l'utilisation de% n dans printf pour réécrire dans la pile. Normalement, printf extrait les valeurs des paramètres de la pile en fonction de la chaîne de format, mais% n peut les réécrire.

Consultez la section 3.4.2 ici . Peut conduire à de nombreuses vulnérabilités désagréables.

Vérification des hypothèses au moment de la compilation à l'aide d'énumérations: exemple stupide, mais peut être vraiment utile pour les bibliothèques avec des constantes configurables au moment de la compilation.

#define D 1
#define DD 2

enum CompileTimeCheck
{
    MAKE_SURE_DD_IS_TWICE_D = 1/(2*(D) == (DD)),
    MAKE_SURE_DD_IS_POW2    = 1/((((DD) - 1) & (DD)) == 0)
};

Gcc (c) a quelques fonctionnalités amusantes que vous pouvez activer, telles que les déclarations de fonctions imbriquées et la forme a?: B de l'opérateur?:, Qui renvoie a si a n'est pas faux.

J'ai découvert récemment 0 bitfields.

struct {
  int    a:3;
  int    b:2;
  int     :0;
  int    c:4;
  int    d:3;
};

qui donnera une mise en page de

000aaabb 0ccccddd

au lieu de sans le: 0;

0000aaab bccccddd

Le champ de largeur 0 indique que les champs de bits suivants doivent être définis sur l'entité atomique suivante ( char)

Macros d'argument de variable de style C99, aka

#define ERR(name, fmt, ...)   fprintf(stderr, "ERROR " #name ": " fmt "\n", \
                                  __VAR_ARGS__)

qui serait utilisé comme

ERR(errCantOpen, "File %s cannot be opened", filename);

Ici, j'utilise également l'opérateur stringize et la concatentation constante de chaîne, d'autres fonctionnalités que j'aime beaucoup.

Les variables automatiques de taille variable sont également utiles dans certains cas. Celles-ci ont été ajoutées sur nC99 et sont prises en charge dans gcc depuis longtemps.

void foo(uint32_t extraPadding) {
    uint8_t commBuffer[sizeof(myProtocol_t) + extraPadding];

Vous vous retrouvez avec un tampon sur la pile avec de la place pour l'en-tête de protocole de taille fixe plus les données de taille variable. Vous pouvez obtenir le même effet avec alloca (), mais cette syntaxe est plus compacte.

Vous devez vous assurer que extraPadding est une valeur raisonnable avant d'appeler cette routine, sinon vous finissez par faire exploser la pile. Vous devrez vérifier les arguments avant d'appeler malloc ou toute autre technique d'allocation de mémoire, donc ce n'est pas vraiment inhabituel.