Какой твой любимый трюк на C? [закрыто]

Например, я недавно сталкивался с этим в ядре Linux:

/ * Принудительная ошибка компиляции, если условие истинно * /
#define BUILD_BUG_ON (условие) ((недействительно) sizeof (символ [1 - 2 * !! (условие)]))

Итак, в вашем коде, если у вас есть какая-то структура, которая должна иметь размер, скажем, кратный 8 байтам, возможно, из-за некоторых аппаратных ограничений, вы можете сделать следующее:

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

и он не скомпилируется, если размер struct mystruct не кратен 8, а если он кратен 8, код времени выполнения вообще не генерируется.

Другой известный мне трюк из книги «Графические жемчужины», которая позволяет одному заголовочному файлу как объявлять, так и инициализировать переменные в одном модуле, тогда как в других модулях, использующих этот модуль, просто объявлять их как внешние.

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
#define INIT (x, y) (x) = (y)
#else
#define GLOBAL extern
#define INIT (x, y)
#endif

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

При этом код, который определяет x и somefunc:

#define DEFINE_MYHEADER_GLOBALS
#include "the_above_header_file.h"

в то время как код, который просто использует x и somefunc (), делает:

#include "the_above_header_file.h"

Таким образом, вы получаете один заголовочный файл, который объявляет как экземпляры глобальных переменных, так и прототипы функций, где они необходимы, и соответствующие объявления extern.

Итак, какие у вас любимые приемы программирования на С в этом направлении?

C99 предлагает некоторые действительно интересные вещи, используя анонимные массивы:

Удаление бессмысленных переменных

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

становится

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

Передача переменного количества аргументов

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

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

Статические связанные списки

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;
    }
}

Во всяком случае, я уверен, что многие другие классные приемы, о которых я не думал.

Читая исходный код Quake 2, я придумал что-то вроде этого:

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

(более или менее, у меня нет кода, чтобы проверить это сейчас).

С тех пор перед моими глазами открылся новый мир творческого использования препроцессора. Я больше не включаю только заголовки, а целые куски кода время от времени (это значительно улучшает возможность повторного использования) :-p

Спасибо Джон Кармак! XD

Я люблю использовать = {0};для инициализации структур без необходимости вызывать memset.

struct something X = {0};

Это инициализирует все члены структуры (или массива) нулями (но не байтами заполнения - используйте memset, если вам нужно также обнулить их).

Но вы должны знать, что есть некоторые проблемы с этим для больших, динамически размещаемых структур .

Если мы говорим о трюках, то моим любимым должен быть прибор Даффа для раскрутки петли! Я просто жду подходящей возможности для меня, чтобы фактически использовать это в гневе ...

используя __FILE__и __LINE__для отладки

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

В 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};

Однажды мой друг и я пересмотрели возвращение, чтобы найти хитрую ошибку с повреждением стека.

Что-то вроде:

#define return DoSomeStackCheckStuff, return

Мне нравится "взлом структуры" для наличия объекта динамического размера. Этот сайт также объясняет это довольно хорошо (хотя они ссылаются на версию C99, где вы можете написать «str []» как последний член структуры). Вы можете сделать строку "объект", как это:

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;

здесь мы выделили структуру типа X в куче, которая является размером с int (для len), плюс длина «hello world», плюс 1 (так как str 1 включена в sizeof (X).

Это обычно полезно, когда вы хотите иметь «заголовок» прямо перед некоторыми данными переменной длины в одном и том же блоке.

Объектно-ориентированный код с C, эмулируя классы.

Просто создайте структуру и набор функций, которые принимают указатель на эту структуру в качестве первого параметра.

Вместо того

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

использование

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

Использование глупого трюка с макросами для упрощения поддержки определений записей.

#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;

Для создания переменной, которая доступна только для чтения во всех модулях, кроме той, в которой она объявлена:

// 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

Сдвиги битов определяются только до величины сдвига 31 (для 32-битного целого).

Что вы делаете, если хотите иметь вычисленный сдвиг, который также должен работать с более высокими значениями сдвига? Вот как это делает видеокодек Theora:

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

Или гораздо более читабельным:

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

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

Выполнение задачи, как показано выше, намного быстрее, чем использование такой ветки:

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

Объявление массива указателей на функции для реализации конечных автоматов.

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

Самое приятное преимущество заключается в том, что каждый стимул / состояние просто заставляет проверять все пути кода.

Во встроенной системе я часто сопоставляю ISR, чтобы указывать на такую ​​таблицу и обнаруживать ее по мере необходимости (за пределами ISR).

Еще один приятный трюк препроцессора - использовать символ «#» для печати выражений отладки. Например:

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

редактировать: приведенный ниже код работает только на C ++. Благодаря smcameron и Эван Теран.

Да, время компиляции всегда хорошее. Это также может быть записано как:

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

Я бы не стал называть это любимым трюком, так как никогда не использовал его, но упоминание об устройстве Даффа напомнило мне об этой статье о реализации Coroutines в C. Это всегда вызывает у меня смех, но я уверен, что это может быть полезным некоторое время

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

В то время как (0); не влияет на программу, но компилятор выдаст предупреждение о том, что «это ничего не делает», и этого достаточно, чтобы я посмотрел на строку с ошибками и увидел реальную причину, по которой я хотел обратить на это внимание.

Я фанат xor хаков

Поменяйте местами 2 указателя без третьего временного указателя:

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

Или мне действительно нравится список ссылок xor только с одним указателем. (Http://en.wikipedia.org/wiki/XOR_linked_list)

Каждый узел в связанном списке - это Xor предыдущего узла и следующего узла. Чтобы перейти вперед, адреса узлов находятся следующим образом:

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

и т.п.

или пройти назад:

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;

и т.п.

Хотя это не очень полезно (вы не можете начать обход с произвольного узла), я считаю, что это очень круто.

Этот из книги «Хватит веревки, чтобы выстрелить себе в ногу»:

В шапке заявляю

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

В вашем коде поместите операторы тестирования, например:

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

Функция do / while помогает в случае, если содержимое макроса расширяется до нескольких операторов.

Оператор будет напечатан только в том случае, если флаг компилятора «-D RELEASE» не используется.

Вы можете тогда, например. передать флаг вашему make-файлу и т. д.

Не уверен, как это работает в Windows, но в * nix это работает хорошо

Rusty на самом деле создал целый набор условных выражений сборки в ccan , проверьте модуль build assert:

#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;
}

В самом заголовке есть много других полезных макросов, которые легко установить на свои места.

Я стараюсь изо всех сил сопротивляться притяжению темной стороны (и злоупотреблению препроцессором), придерживаясь в основном встроенных функций, но мне нравятся умные, полезные макросы, подобные тем, которые вы описали.

Двумя хорошими исходными книгами для такого рода вещей являются «Практика программирования и написания твердого кода» . Один из них (я не помню, какой именно) говорит: предпочитайте enum вместо #define, где вы можете, потому что enum проверяется компилятором.

Не относится к C, но мне всегда нравился оператор XOR. Одна крутая вещь, которую он может сделать, это «своп без временного значения»:

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);

Результат:

а = 1, б = 2

а = 2, б = 1

Смотрите вопрос «Скрытые возможности С» .

Мне нравится понятие, container_ofиспользуемое, например, в списках. В принципе, вам не нужно указывать nextи lastполя для каждой структуры, которые будут в списке. Вместо этого вы добавляете заголовок структуры списка к фактическим связанным элементам.

Посмотрите на include/linux/list.hреальные примеры.

Я думаю, что использование указателей userdata довольно аккуратно. Мода сдает позиции в наши дни. Это не столько функция C, но довольно простая в использовании в C.

Я использую X-Macros, чтобы позволить прекомпилятору генерировать код. Они особенно полезны для определения значений ошибок и связанных строк ошибок в одном месте, но они могут пойти гораздо дальше.

Наша кодовая база имеет трюк, похожий на

#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
}

который позволяет отслеживать утечки памяти в режиме отладки. Я всегда думал, что это круто.

Приколы с макросами:

#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
     }
}

Вот пример того, как сделать код на C полностью не осведомленным о том, что на самом деле используется HW для запуска приложения. Main.c выполняет настройку, и затем свободный слой может быть реализован на любом компиляторе / арке. Я думаю, что это довольно удобно для абстрагирования кода на C, так что оно не будет особенным.

Добавляем полный скомпилированный пример здесь.

/* 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");

Заполните пропуски, чтобы ни привет, ни привет не появлялись на выходе.
анс:fclose(stdout)