Quelle est votre astuce de programmation C préférée? [fermé]

Par exemple, je suis récemment tombé sur ceci dans le noyau Linux:

/ * Forcer une erreur de compilation si la condition est vraie * /
#define BUILD_BUG_ON (condition) ((void) sizeof (char [1 - 2 * !! (condition)]))

Donc, dans votre code, si vous avez une structure qui doit être, disons un multiple de 8 octets, peut-être à cause de certaines contraintes matérielles, vous pouvez faire:

BUILD_BUG_ON ((sizeof (struct mystruct)% 8)! = 0);

et il ne se compilera que si la taille de struct mystruct est un multiple de 8, et s'il s'agit d'un multiple de 8, aucun code d'exécution n'est généré du tout.

Une autre astuce que je connais vient du livre "Graphics Gems" qui permet à un seul fichier d'en-tête à la fois de déclarer et d'initialiser des variables dans un module tandis que dans d'autres modules utilisant ce module, il suffit de les déclarer comme externes.

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
#define INIT (x, y) (x) = (y)
#autre
#define GLOBAL extern
#define INIT (x, y)
#fin si

GLOBAL int INIT (x, 0);
GLOBAL int somefunc (int a, int b);

Avec cela, le code qui définit x et somefunc fait:

#define DEFINE_MYHEADER_GLOBALS
#include "the_above_header_file.h"

tandis que le code qui utilise simplement x et somefunc () fait:

#include "the_above_header_file.h"

Vous obtenez donc un fichier d'en-tête qui déclare à la fois les instances de globals et les prototypes de fonction là où ils sont nécessaires, ainsi que les déclarations externes correspondantes.

Alors, quelles sont vos astuces de programmation C préférées dans ce sens?

C99 propose des trucs vraiment sympas en utilisant des tableaux anonymes:

Supprimer les variables inutiles

{
    int yes=1;
    setsockopt(yourSocket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
}

devient

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

Passer une quantité variable d'arguments

void func(type* values) {
    while(*values) {
        x = *values++;
        /* do whatever with x */
    }
}

func((type[]){val1,val2,val3,val4,0});

Listes liées statiques

int main() {
    struct llist { int a; struct llist* next;};
    #define cons(x,y) (struct llist[]){{x,y}}
    struct llist *list=cons(1, cons(2, cons(3, cons(4, NULL))));
    struct llist *p = list;
    while(p != 0) {
        printf("%d\n", p->a);
        p = p->next;
    }
}

Je suis sûr que beaucoup d'autres techniques intéressantes auxquelles je n'ai pas pensé.

En lisant le code source de Quake 2, j'ai trouvé quelque chose comme ceci:

double normals[][] = {
  #include "normals.txt"
};

(plus ou moins, je n'ai pas le code à portée de main pour le vérifier maintenant).

Depuis, un nouveau monde d'utilisation créative du préprocesseur s'est ouvert sous mes yeux. Je n'inclus plus que des en-têtes, mais des morceaux entiers de code de temps en temps (cela améliore beaucoup la réutilisabilité) :-p

Merci John Carmack! xD

J'aime utiliser = {0}; pour initialiser des structures sans avoir besoin d'appeler memset.

struct something X = {0};

Cela initialisera tous les membres de la structure (ou du tableau) à zéro (mais pas les octets de remplissage - utilisez memset si vous devez également les remettre à zéro).

Mais vous devez être conscient que cela pose certains problèmes pour les grandes structures allouées dynamiquement .

Si nous parlons de trucs c, mon préféré doit être Duff's Device pour le déroulement de la boucle! J'attends juste la bonne opportunité pour que je l'utilise avec colère ...

utilisation __FILE__et __LINE__pour le débogage

#define WHERE fprintf(stderr,"[LOG]%s:%d\n",__FILE__,__LINE__);

En C99

typedef struct{
    int value;
    int otherValue;
} s;

s test = {.value = 15, .otherValue = 16};

/* or */
int a[100] = {1,2,[50]=3,4,5,[23]=6,7};

Une fois un de mes compagnons et moi avons redéfini le retour pour trouver un bug de corruption de pile délicat.

Quelque chose comme:

#define return DoSomeStackCheckStuff, return

J'aime le "struct hack" pour avoir un objet de taille dynamique. Ce site l' explique assez bien aussi (bien qu'ils se réfèrent à la version C99 où vous pouvez écrire "str []" comme dernier membre d'une structure). vous pouvez créer une chaîne "objet" comme ceci:

struct X {
    int len;
    char str[1];
};

int n = strlen("hello world");
struct X *string = malloc(sizeof(struct X) + n);
strcpy(string->str, "hello world");
string->len = n;

ici, nous avons alloué une structure de type X sur le tas qui a la taille d'un int (pour len), plus la longueur de "hello world", plus 1 (puisque str 1 est inclus dans sizeof (X).

Il est généralement utile lorsque vous voulez avoir un "en-tête" juste avant des données de longueur variable dans le même bloc.

Code orienté objet avec C, en émulant des classes.

Créez simplement une structure et un ensemble de fonctions qui prennent un pointeur vers cette structure comme premier paramètre.

Au lieu de

printf("counter=%d\n",counter);

Utilisation

#define print_dec(var)  printf("%s=%d\n",#var,var);
print_dec(counter);

Utiliser une astuce de macro stupide pour rendre les définitions d'enregistrement plus faciles à maintenir.

#define COLUMNS(S,E) [(E) - (S) + 1]

typedef struct
{
    char studentNumber COLUMNS( 1,  9);
    char firstName     COLUMNS(10, 30);
    char lastName      COLUMNS(31, 51);

} StudentRecord;

Pour créer une variable qui est en lecture seule dans tous les modules sauf celui dans lequel elle est déclarée:

// Header1.h:

#ifndef SOURCE1_C
   extern const int MyVar;
#endif

// Source1.c:

#define SOURCE1_C
#include Header1.h // MyVar isn't seen in the header

int MyVar; // Declared in this file, and is writeable

// Source2.c

#include Header1.h // MyVar is seen as a constant, declared elsewhere

Les décalages de bits ne sont définis que jusqu'à une valeur de décalage de 31 (sur un entier de 32 bits).

Que faites-vous si vous voulez avoir un quart de travail calculé qui doit également fonctionner avec des valeurs de quart plus élevées? Voici comment le vide-codec Theora le fait:

unsigned int shiftmystuff (unsigned int a, unsigned int v)
{
  return (a>>(v>>1))>>((v+1)>>1);
}

Ou bien plus lisible:

unsigned int shiftmystuff (unsigned int a, unsigned int v)
{
  unsigned int halfshift = v>>1;
  unsigned int otherhalf = (v+1)>>1;

  return (a >> halfshift) >> otherhalf; 
}

Effectuer la tâche de la manière indiquée ci-dessus est beaucoup plus rapide que d'utiliser une branche comme celle-ci:

unsigned int shiftmystuff (unsigned int a, unsigned int v)
{
  if (v<=31)
    return a>>v;
  else
    return 0;
}

Déclarer des tableaux de pointeurs vers des fonctions pour implémenter des machines à états finis.

int (* fsm[])(void) = { ... }

L'avantage le plus agréable est qu'il est simple de forcer chaque stimulus / état à vérifier tous les chemins de code.

Dans un système embarqué, je mapperai souvent un ISR pour pointer vers une telle table et le réviserai si nécessaire (en dehors des ISR).

Un autre "truc" du préprocesseur est d'utiliser le caractère "#" pour imprimer les expressions de débogage. Par exemple:

#define MY_ASSERT(cond) \
  do { \
    if( !(cond) ) { \
      printf("MY_ASSERT(%s) failed\n", #cond); \
      exit(-1); \
    } \
  } while( 0 )

edit: le code ci-dessous ne fonctionne que sur C ++. Merci à smcameron et Evan Teran.

Oui, l'affirmation du temps de compilation est toujours excellente. Il peut également s'écrire:

#define COMPILE_ASSERT(cond)\
     typedef char __compile_time_assert[ (cond) ? 0 : -1]

Je n'appellerais pas vraiment cela une astuce préférée, car je ne l'ai jamais utilisé, mais la mention de Duff's Device m'a rappelé cet article sur la mise en œuvre de Coroutines en C. Cela me fait toujours rire, mais je suis sûr que cela pourrait être utile quelque temps.

#if TESTMODE == 1    
    debug=1;
    while(0);     // Get attention
#endif

Le while (0); n'a aucun effet sur le programme, mais le compilateur émettra un avertissement à propos de "cela ne fait rien", ce qui est suffisant pour me faire aller regarder la ligne incriminée et voir ensuite la vraie raison pour laquelle je voulais attirer l'attention sur elle.

Je suis fan des hacks xor:

Échangez 2 pointeurs sans troisième pointeur temporaire:

int * a;
int * b;
a ^= b;
b ^= a;
a ^= b;

Ou j'aime vraiment la liste chaînée xor avec un seul pointeur. (http://en.wikipedia.org/wiki/XOR_linked_list)

Chaque nœud de la liste liée est le Xor du nœud précédent et du nœud suivant. Pour avancer, l'adresse des nœuds se trouve de la manière suivante:

LLNode * first = head;
LLNode * second = first.linked_nodes;
LLNode * third = second.linked_nodes ^ first;
LLNode * fourth = third.linked_nodes ^ second;

etc.

ou pour reculer:

LLNode * last = tail;
LLNode * second_to_last = last.linked_nodes;
LLNode * third_to_last = second_to_last.linked_nodes ^ last;
LLNode * fourth_to_last = third_to_last.linked_nodes ^ second_to_last;

etc.

Bien que cela ne soit pas très utile (vous ne pouvez pas commencer à traverser à partir d'un nœud arbitraire), je trouve que c'est très cool.

Celui-ci vient du livre 'Assez de corde pour vous tirer une balle dans le pied':

Dans l'en-tête déclarer

#ifndef RELEASE
#  define D(x) do { x; } while (0)
#else
#  define D(x)
#endif

Dans vos instructions de test de lieu de code, par exemple:

D(printf("Test statement\n"));

Le do / while aide au cas où le contenu de la macro se développerait en plusieurs instructions.

L'instruction ne sera imprimée que si l'indicateur «-D RELEASE» du compilateur n'est pas utilisé.

Vous pouvez alors par exemple. passez le drapeau à votre makefile etc.

Je ne sais pas comment cela fonctionne dans Windows mais dans * nix cela fonctionne bien

Rusty a en fait produit tout un ensemble de conditions de construction dans ccan , consultez le module d' assertion de construction:

#include <stddef.h>
#include <ccan/build_assert/build_assert.h>

struct foo {
        char string[5];
        int x;
};

char *foo_string(struct foo *foo)
{
        // This trick requires that the string be first in the structure
        BUILD_ASSERT(offsetof(struct foo, string) == 0);
        return (char *)foo;
}

Il y a beaucoup d'autres macros utiles dans l'en-tête réel, qui sont faciles à mettre en place.

J'essaie, de toutes mes forces, de résister à l'attraction du côté obscur (et à l'abus des préprocesseurs) en m'en tenant principalement aux fonctions en ligne, mais j'aime les macros intelligentes et utiles comme celles que vous avez décrites.

Deux bons livres sources pour ce genre de choses sont The Practice of Programming and Writing Solid Code . L'un d'eux (je ne me souviens pas lequel) dit: Préférez enum à #define là où vous le pouvez, car enum est vérifié par le compilateur.

Pas spécifique à C, mais j'ai toujours aimé l'opérateur XOR. Une chose intéressante à faire est de "permuter sans valeur de température":

int a = 1;
int b = 2;

printf("a = %d, b = %d\n", a, b);

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

printf("a = %d, b = %d\n", a, b);

Résultat:

a = 1, b = 2

a = 2, b = 1

Voir la question «Fonctionnalités cachées de C» .

J'aime le concept de container_ofutilisé par exemple dans les listes. En gros, vous n'avez pas besoin de spécifier nextetlast champs pour chaque structure qui sera dans la liste. Au lieu de cela, vous ajoutez l'en-tête de la structure de liste aux éléments liés réels.

Jetez un œil include/linux/list.haux exemples réels.

Je pense que l'utilisation des pointeurs userdata est assez soignée. Une mode qui perd du terrain de nos jours. Ce n'est pas tellement une fonctionnalité C mais c'est assez facile à utiliser en C.

J'utilise X-Macros pour laisser le pré-compilateur générer du code. Ils sont particulièrement utiles pour définir les valeurs d'erreur et les chaînes d'erreur associées en un seul endroit, mais ils peuvent aller bien au-delà.

Notre base de code a une astuce similaire à

#ifdef DEBUG

#define my_malloc(amt) my_malloc_debug(amt, __FILE__, __LINE__)
void * my_malloc_debug(int amt, char* file, int line)
#else
void * my_malloc(int amt)
#endif
{
    //remember file and line no. for this malloc in debug mode
}

qui permet le suivi des fuites de mémoire en mode débogage. J'ai toujours pensé que c'était cool.

Amusez-vous avec les macros:

#define SOME_ENUMS(F) \
    F(ZERO, zero) \
    F(ONE, one) \
    F(TWO, two)

/* Now define the constant values.  See how succinct this is. */

enum Constants {
#define DEFINE_ENUM(A, B) A,
    SOME_ENUMS(DEFINE_ENUMS)
#undef DEFINE_ENUM
};

/* Now a function to return the name of an enum: */

const char *ToString(int c) {
    switch (c) {
    default: return NULL; /* Or whatever. */
#define CASE_MACRO(A, B) case A: return #b;
     SOME_ENUMS(CASE_MACRO)
#undef CASE_MACRO
     }
}

Voici un exemple comment rendre le code C complètement inconscient de ce qui est réellement utilisé de HW pour exécuter l'application. Le main.c fait l'installation et ensuite la couche libre peut être implémentée sur n'importe quel compilateur / arch. Je pense que c'est assez sympa pour faire abstraction un peu du code C, donc ça ne peut pas être trop spécifique.

Ajout d'un exemple complet compilable ici.

/* free.h */
#ifndef _FREE_H_
#define _FREE_H_
#include <stdio.h>
#include <string.h>
typedef unsigned char ubyte;

typedef void (*F_ParameterlessFunction)() ;
typedef void (*F_CommandFunction)(ubyte byte) ;

void F_SetupLowerLayer (
F_ParameterlessFunction initRequest,
F_CommandFunction sending_command,
F_CommandFunction *receiving_command);
#endif

/* free.c */
static F_ParameterlessFunction Init_Lower_Layer = NULL;
static F_CommandFunction Send_Command = NULL;
static ubyte init = 0;
void recieve_value(ubyte my_input)
{
    if(init == 0)
    {
        Init_Lower_Layer();
        init = 1;
    }
    printf("Receiving 0x%02x\n",my_input);
    Send_Command(++my_input);
}

void F_SetupLowerLayer (
    F_ParameterlessFunction initRequest,
    F_CommandFunction sending_command,
    F_CommandFunction *receiving_command)
{
    Init_Lower_Layer = initRequest;
    Send_Command = sending_command;
    *receiving_command = &recieve_value;
}

/* main.c */
int my_hw_do_init()
{
    printf("Doing HW init\n");
    return 0;
}
int my_hw_do_sending(ubyte send_this)
{
    printf("doing HW sending 0x%02x\n",send_this);
    return 0;
}
F_CommandFunction my_hw_send_to_read = NULL;

int main (void)
{
    ubyte rx = 0x40;
    F_SetupLowerLayer(my_hw_do_init,my_hw_do_sending,&my_hw_send_to_read);

    my_hw_send_to_read(rx);
    getchar();
    return 0;
}

if(---------)  
printf("hello");  
else   
printf("hi");

Remplissez les espaces pour que ni bonjour ni salut n'apparaissent dans la sortie.
ans:fclose(stdout)