Який улюблений трюк програмування на С? [зачинено]

Наприклад, я нещодавно натрапив на це в ядрі Linux:

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

Отже, у своєму коді, якщо у вас є якась структура, яка повинна бути, скажімо, кратне 8 байт, можливо, через деякі апаратні обмеження, ви можете зробити:

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

і він не буде компілюватися, якщо розмір структури mystruct не є кратним 8, а якщо він кратний 8, взагалі не створюється код виконання.

Ще одна хитрість, яку я знаю, - це книга "Графічні дорогоцінні камені", яка дозволяє одному файлу заголовка оголошувати і ініціалізувати змінні в одному модулі, а в інших модулях, що використовують цей модуль, просто оголошувати їх як екстернали.

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
#define INIT (x, y) (x) = (y)
#else
#define GLOBAL екстерн
#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"

Таким чином, ви отримуєте один заголовок, який оголошує як екземпляри глобалів, так і прототипи функцій там, де вони потрібні, та відповідні зовнішні декларації.

Отже, які ваші улюблені трюки з програмування на C?

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, якщо вам також потрібно нулювати їх).

Але вам слід пам’ятати, що для великих, динамічно розподілених структур є деякі проблеми .

Якщо ми говоримо про фокуси c, моїм улюбленим має бути пристрій Даффа для розгортання циклу! Я просто чекаю правильної можливості прийти до мене, щоб насправді використати це в гніві ...

використання __FILE__та __LINE__для налагодження

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

У С99

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 входить до розміруof (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).

Ще одна приємна "хитрість" перед процесором - використовувати символ "#" для друку виразів налагодження. Наприклад:

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

Я б насправді не назвав це улюбленим трюком, оскільки я ніколи його не використовував, але згадка про пристрої Даффа нагадала мені цю статтю про реалізацію Коротингів у 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'.

Ви можете, наприклад, передайте прапор у ваш makefile тощо.

Не впевнений, як це працює у Windows, але в * nix це добре працює

Расті фактично створив цілий набір умовних умов побудови в мові , перевірте модуль затвердження збірки:

#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, де можна, тому що перелік перевіряється компілятором.

Не характерно для 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);

Результат:

a = 1, b = 2

a = 2, b = 1

Див . Питання "Приховані особливості C" .

Мені подобається концепція, що 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");

Заповніть заготовки, щоб ні привіт, ні привіт не з’явились у виході.
ans:fclose(stdout)