Jaka jest twoja ulubiona sztuczka programistyczna w C? [Zamknięte]

Na przykład niedawno natknąłem się na to w jądrze Linuksa:

/ * Wymuś błąd kompilacji, jeśli warunek jest prawdziwy * /
# zdefiniować BUILD_BUG_ON (warunek) ((void) sizeof (char [1 - 2 * !! (warunek)]))

Tak więc w swoim kodzie, jeśli masz jakąś strukturę, która musi mieć, powiedzmy, wielokrotność 8 bajtów, być może z powodu pewnych ograniczeń sprzętowych, możesz zrobić:

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

i nie skompiluje się, chyba że rozmiar struct mystruct jest wielokrotnością 8, a jeśli jest wielokrotnością 8, nie jest generowany żaden kod wykonawczy.

Inna sztuczka, którą znam, pochodzi z książki „Graphics Gems”, która pozwala pojedynczemu plikowi nagłówkowemu zarówno deklarować, jak i inicjować zmienne w jednym module, podczas gdy w innych modułach używających tego modułu, po prostu deklaruje je jako zewnętrzne.

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
# zdefiniować INIT (x, y) (x) = (y)
#jeszcze
#define GLOBAL extern
# zdefiniować INIT (x, y)
#endif

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

Dzięki temu kod, który definiuje x i somefunc, robi:

# zdefiniować DEFINE_MYHEADER_GLOBALS
#include „the_above_header_file.h”

podczas gdy kod, który używa tylko x i somefunc (), robi:

#include „the_above_header_file.h”

Otrzymujesz więc jeden plik nagłówkowy, który deklaruje zarówno instancje zmiennych globalnych, jak i prototypy funkcji tam, gdzie są potrzebne, oraz odpowiadające im deklaracje extern.

Więc jakie są twoje ulubione sztuczki programowania w C w tym zakresie?

C99 oferuje naprawdę fajne rzeczy przy użyciu anonimowych tablic:

Usuwanie bezsensownych zmiennych

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

staje się

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

Przekazywanie zmiennej ilości argumentów

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

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

Statyczne listy połączone

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

Jestem pewien, że jest wiele innych fajnych technik, o których nie pomyślałem.

Czytając kod źródłowy Quake 2 wymyśliłem coś takiego:

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

(mniej więcej, nie mam pod ręką kodu, żeby to sprawdzić).

Od tamtej pory na moich oczach otworzył się nowy świat twórczego wykorzystania preprocesora. Nie dołączam już tylko nagłówków, ale od czasu do czasu całe fragmenty kodu (znacznie poprawia to możliwość ponownego wykorzystania) :-p

Dzięki, John Carmack! xD

Lubię używać = {0};do inicjowania struktur bez konieczności wywoływania memset.

struct something X = {0};

Spowoduje to zainicjowanie wszystkich członków struktury (lub tablicy) do zera (ale nie żadnych bajtów uzupełniających - użyj memset, jeśli chcesz wyzerować również te).

Ale powinieneś być świadomy, że istnieją pewne problemy z tym w przypadku dużych, dynamicznie alokowanych struktur .

Jeśli mówimy o trikach C, moim ulubionym jest Urządzenie Duffa do rozwijania pętli! Po prostu czekam na odpowiednią okazję, aby przyjść i użyć jej w gniewie ...

używanie __FILE__i __LINE__do debugowania

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

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

Kiedyś mój kumpel i ja przedefiniowaliśmy powrót, aby znaleźć trudny błąd powodujący uszkodzenie stosu.

Coś jak:

#define return DoSomeStackCheckStuff, return

Podoba mi się „struct hack” za obiekt o dynamicznych rozmiarach. Ta strona również dobrze to wyjaśnia (chociaż odnoszą się do wersji C99, w której można napisać „str []” jako ostatni element struktury). możesz utworzyć łańcuch „obiekt” w ten sposób:

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;

tutaj przydzieliliśmy strukturę typu X na stercie, która jest wielkością int (dla len) plus długość „hello world” plus 1 (ponieważ str 1 jest zawarty w sizeof (X).

Jest to ogólnie przydatne, gdy chcesz mieć „nagłówek” tuż przed niektórymi danymi o zmiennej długości w tym samym bloku.

Kod zorientowany obiektowo w C, poprzez emulację klas.

Po prostu utwórz strukturę i zestaw funkcji, które przyjmą wskaźnik do tej struktury jako pierwszy parametr.

Zamiast

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

Posługiwać się

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

Używanie głupiej sztuczki z makrami, aby ułatwić zarządzanie definicjami rekordów.

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

Do tworzenia zmiennej, która jest tylko do odczytu we wszystkich modułach oprócz tego, który jest zadeklarowany w:

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

Przesunięcia bitowe są definiowane tylko do wartości przesunięcia 31 (na 32-bitowej liczbie całkowitej).

Co robisz, jeśli chcesz mieć obliczoną zmianę, która musi pracować również z wyższymi wartościami przesunięcia? Oto, jak robi to kodek wideo Theora:

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

Lub znacznie bardziej czytelne:

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

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

Wykonanie zadania w sposób pokazany powyżej jest o wiele szybsze niż użycie takiej gałęzi:

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

Deklarowanie tablicy wskaźników do funkcji implementujących maszyny skończone.

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

Najbardziej przyjemną zaletą jest to, że łatwo jest wymusić na każdym bodźcu / stanie sprawdzenie wszystkich ścieżek kodu.

W systemie osadzonym często mapuję ISR, aby wskazywał na taką tabelę i poprawiałam ją w razie potrzeby (poza ISR).

Inną fajną „sztuczką” preprocesora jest użycie znaku „#” do wypisania wyrażeń debugujących. Na przykład:

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

edycja: poniższy kod działa tylko w C ++. Dzięki smcameron i Evan Teran.

Tak, asercja czasu kompilacji jest zawsze świetna. Można go również zapisać jako:

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

Naprawdę nie nazwałbym tego ulubioną sztuczką, ponieważ nigdy jej nie użyłem, ale wzmianka o urządzeniu Duffa przypomniała mi o tym artykule o wdrażaniu Coroutines w C. Zawsze mnie chichocze, ale jestem pewien, że tak. przyda się kiedyś.

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

Podczas gdy (0); nie ma wpływu na program, ale kompilator wyświetli ostrzeżenie o tym, że „to nic nie robi”, co wystarczy, żebym spojrzał na nieprawidłową linię i zobaczył prawdziwy powód, dla którego chciałem zwrócić na nią uwagę.

Jestem fanem hacków xor:

Zamień 2 wskaźniki bez trzeciego wskaźnika temp:

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

Lub bardzo podoba mi się lista połączona z xor z tylko jednym wskaźnikiem. (http://en.wikipedia.org/wiki/XOR_linked_list)

Każdy węzeł na połączonej liście jest Xor poprzedniego i następnego węzła. Aby przejść dalej, adresy węzłów znajdują się w następujący sposób:

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

itp.

lub aby przejść wstecz:

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;

itp.

Chociaż nie jest to strasznie przydatne (nie można rozpocząć przechodzenia z dowolnego węzła), uważam to za bardzo fajne.

Ten pochodzi z książki „Dość liny, by strzelić sobie w stopę”:

W nagłówku zadeklaruj

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

W Twoim kodzie umieść instrukcje testujące, np .:

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

Do / while pomaga w przypadku, gdy zawartość makra rozszerza się na wiele instrukcji.

Instrukcja zostanie wydrukowana tylko wtedy, gdy flaga '-D RELEASE' dla kompilatora nie zostanie użyta.

Możesz wtedy np. przekazać flagę do pliku makefile itp.

Nie jestem pewien, jak to działa w systemie Windows, ale w * nix działa dobrze

Rusty faktycznie wyprodukował cały zestaw warunków kompilacji w ccan , sprawdź moduł asercji kompilacji:

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

W samym nagłówku znajduje się wiele innych pomocnych makr, które można łatwo wstawić.

Z całych sił staram się oprzeć ciemnej stronie (i nadużyciom preprocesora), trzymając się głównie funkcji wbudowanych, ale lubię sprytne, przydatne makra, takie jak te, które opisałeś.

Dwie dobre książki źródłowe do tego typu rzeczy to The Practice of Programming and Writing Solid Code . Jeden z nich (nie pamiętam, który) mówi: Preferuj enum do #define, gdzie możesz, ponieważ enum jest sprawdzane przez kompilator.

Nie dotyczy C, ale zawsze lubiłem operator XOR. Jedną fajną rzeczą, jaką może zrobić, jest „zamiana bez wartości temp”:

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

Wynik:

a = 1, b = 2

a = 2, b = 1

Zobacz pytanie „Ukryte funkcje języka C” .

Podoba mi się koncepcja container_ofużywana na przykład w listach. Zasadniczo nie musisz określać nexti lastpól dla każdej struktury, która będzie na liście. Zamiast tego należy dołączyć nagłówek struktury listy do rzeczywistych połączonych elementów.

Spójrz na include/linux/list.hprzykłady z życia wzięte.

Myślę, że użycie wskaźników userdata jest całkiem fajne. Moda traci dziś na popularności. Nie jest to funkcja C, ale dość łatwa w użyciu w C.

Używam X-Macros, aby umożliwić prekompilatorowi wygenerowanie kodu. Są szczególnie przydatne do definiowania wartości błędów i powiązanych ciągów błędów w jednym miejscu, ale mogą wykraczać daleko poza to.

Nasza baza kodów ma podobną sztuczkę do

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

co pozwala na śledzenie wycieków pamięci w trybie debugowania. Zawsze myślałem, że to fajne.

Zabawa z makrami:

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

Oto przykład, jak sprawić, aby kod C był całkowicie nieświadomy tego, co jest faktycznie używane przez sprzęt do uruchamiania aplikacji. Plik main.c wykonuje konfigurację, a następnie wolną warstwę można zaimplementować na dowolnym kompilatorze / arch. Myślę, że jest to całkiem fajne do trochę abstrakcji kodu C, więc nie musi być zbyt sprecyzowane.

Dodanie tutaj pełnego kompilowalnego przykładu.

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

Wypełnij puste pola, aby na wyjściu nie pojawiały się ani cześć, ani cześć.
ans:fclose(stdout)