En sevdiğiniz C programlama hilesi nedir? [kapalı]

Örneğin, son zamanlarda linux çekirdeğinde bununla karşılaştım:

/ * Koşul doğruysa bir derleme hatasını zorla * /
#define BUILD_BUG_ON (koşul) ((geçersiz) sizeof (karakter [1 - 2 * !! (koşul)]))

Bu nedenle, kodunuzda, belki de bazı donanım kısıtlamaları nedeniyle, 8 baytın katlarından biri olması gereken bir yapıya sahipseniz, şunları yapabilirsiniz:

BUILD_BUG_ON ((sizeof (yapı gizemi)% 8)! = 0);

ve struct mystruct boyutu 8'in katı değilse ve 8'in katı ise hiçbir çalışma zamanı kodu üretilmezse derlenmez.

Bildiğim başka bir numara, tek bir başlık dosyasının bir modüldeki değişkenleri hem modül olarak tanımlamasına hem de başlatmasına izin veren "Grafik Taşları" kitabından kaynaklanıyor.

#ifdef DEFINE_MYHEADER_GLOBALS
#define KÜRESEL
#define INIT (x, y) (x) = (y)
#Başka
#define GLOBAL extern
#define INIT (x, y)
#endif

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

Bununla birlikte, x ve somefunc'u tanımlayan kod şunları yapar:

#define DEFINE_MYHEADER_GLOBALS
#include "the_above_header_file.h"

yalnızca x ve somefunc () kullanan kodlar:

#include "the_above_header_file.h"

Böylece, hem globallerin hem de ihtiyaç duydukları yerde işlev prototiplerinin ve karşılık gelen extern bildirimlerinin bildirildiği bir başlık dosyası alırsınız.

Peki, bu hatlar boyunca en sevdiğiniz C programlama hileleri nelerdir?

C99, anonim diziler kullanarak gerçekten harika şeyler sunar:

Anlamsız değişkenleri kaldırma

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

olur

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

Değişken Bir Değişken Miktarını Geçme

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

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

Statik bağlantılı listeler

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

Herhangi bir eminim aklıma hiç gelmemiş birçok teknik.

Quake 2 kaynak kodunu okurken şöyle bir şey buldum:

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

(az ya da çok, şimdi kontrol etmek için kullanışlı kod yok).

O zamandan beri, önişlemcinin yaratıcı kullanımının yeni bir dünyası gözlerimin önünde açıldı. Artık sadece üstbilgileri içermez, ancak şimdi ve sonra tüm kod parçaları (yeniden kullanılabilirliği çok geliştirir) :-p

Teşekkürler John Carmack! xD

= {0};Memset çağırmaya gerek kalmadan yapıları başlatmak için kullanmaktan hoşlanıyorum .

struct something X = {0};

Bu, yapı (veya dizinin) tüm üyelerini sıfıra başlatır (ancak herhangi bir dolgu baytı değil - bunları sıfırlamanız gerekiyorsa memset kullanın).

Ancak , büyük ve dinamik olarak ayrılmış yapılar için bununla ilgili bazı sorunlar olduğunu bilmelisiniz .

Eğer c hilelerden bahsediyorsak, favorim loop unrolling için Duff'ın Cihazı olmalı ! Sadece onu öfkeyle kullanmam için doğru fırsatı bekliyorum ...

hata ayıklama için __FILE__ve kullanma __LINE__

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

C99'da

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

Bir zamanlar bir eşim ve ben zor bir yığın yolsuzluk hata bulmak için geri tanımladı.

Gibi bir şey:

#define return DoSomeStackCheckStuff, return

Ben dinamik boyutlu bir nesneye sahip olduğu için "struct hack" seviyorum. Bu site de oldukça iyi açıklıyor (bir yapının son üyesi olarak "str []" yazabileceğiniz C99 sürümüne atıfta bulunsalar da). şöyle bir "nesne" dizesi yapabilirsiniz:

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;

burada, öbek üzerinde bir int (len için), artı "merhaba dünya", artı 1 (X 1 boyutuna dahil edildiği için) olan X tipi bir yapı tahsis ettik .

Aynı blokta bazı değişken uzunluklu verilerden hemen önce bir "üstbilgi" olmasını istediğinizde genellikle kullanışlıdır.

Sınıfları öykünerek C ile nesne yönelimli kod.

Basitçe, bir yapı ve bu yapıya bir işaretçi ilk parametre olarak götüren bir dizi işlev oluşturun.

Onun yerine

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

kullanım

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

Kayıt tanımlarının bakımını kolaylaştırmak için aptal bir makro hile kullanmak.

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

Belirtildiği dışında tüm modüllerde salt okunur olan bir değişken oluşturmak için:

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

Bit kaydırmaları yalnızca 31 (32 bit tamsayıda) kaydırma miktarına kadar tanımlanır.

Daha yüksek vardiya değerleriyle de çalışması gereken hesaplanmış bir vardiya almak istiyorsanız ne yaparsınız? Theora vide-codec bileşeni bunu şöyle yapar:

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

Veya çok daha okunabilir:

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

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

Görevi yukarıda gösterilen şekilde gerçekleştirmek, böyle bir dalı kullanmaktan daha hızlıdır:

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

Sonlu durum makinelerini uygulama işlevlerine yönelik işaretçi dizisinin bildirilmesi.

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

En hoş avantaj, her uyarıcıyı / durumu tüm kod yollarını kontrol etmeye zorlamanın basit olmasıdır.

Gömülü bir sistemde, sık sık böyle bir tabloya işaret etmek ve gerektiğinde (ISR dışında) revize etmek için bir ISR'yi eşleştireceğim.

Başka bir güzel ön işlemci "hile" hata ayıklama ifadeleri yazdırmak için "#" karakteri kullanmaktır. Örneğin:

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

Düzenle: aşağıdaki kod sadece C ++ üzerinde çalışır. Smcameron ve Evan Teran'a teşekkürler.

Evet, derleme zamanı ifadesi her zaman mükemmeldir. Ayrıca şu şekilde de yazılabilir:

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

Daha önce hiç kullanmadığım için gerçekten favori bir hile demem, ama Duff'ın Cihazından bahsetmek bana Coroutines'i C'de uygulamakla ilgili bu makaleyi hatırlattı. bir süre faydalı olabilir.

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

Süre (0); program üzerinde hiçbir etkisi yoktur, ancak derleyici "bu hiçbir şey yapmaz" hakkında bir uyarı yayınlar, bu da beni rahatsız edici çizgiye bakıp daha sonra dikkat çekmek istediğim gerçek nedeni görmemi sağlamak için yeterlidir.

Ben xor hacks hayranıyım:

Üçüncü işaretçi olmadan 2 işaretçi değiştirin:

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

Ya da sadece bir işaretçiyle xor bağlantılı listeyi seviyorum. (Http://en.wikipedia.org/wiki/XOR_linked_list)

Bağlantılı listedeki her düğüm, önceki düğümün ve sonraki düğümün Xor'udur. İleriye doğru gitmek için, düğümlerin adresi aşağıdaki şekilde bulunur:

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

vb.

veya geriye doğru gitmek için:

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;

vb.

Çok yararlı olmasa da (rastgele bir düğümden geçmeye başlayamazsınız) çok havalı olduğunu düşünüyorum.

Bu, 'kendini ayağa vurmak için yeterli ip' kitabından geliyor:

Üstbilgi beyanında

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

Kodunuzda test ifadeleri yerleştirin:

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

Do / while, makronun içeriğinin birden çok ifadeye genişlemesi durumunda yardımcı olur.

Deyim yalnızca derleyici için '-D RELEASE' bayrağı kullanılmazsa yazdırılır.

Sonra örneğin. bayrağı makefile vb. geçirin.

Bunun pencerelerde nasıl çalıştığından emin değilim ama * nix'te iyi çalışıyor

Rusty aslında inşa Koşullamalar bir bütün seti üretti ccan inşa assert modülüne göz atın:

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

Gerçek üstbilgide, yerine kolayca bırakılabilecek diğer birçok yararlı makro vardır.

Tüm gücümle, çoğunlukla satır içi işlevlere bağlı kalarak karanlık tarafın çekilmesine (ve önişlemci kötüye kullanımına) karşı koymaya çalışıyorum, ancak tarif ettiğiniz gibi akıllı, kullanışlı makrolardan hoşlanıyorum.

Bu tür şeyler için iki iyi kaynak kitap Programlama ve Katı Kod Yazma Uygulamasıdır . Bunlardan biri (hangisini hatırlamıyorum) diyor ki: # enum'u yapabildiğiniz yere tanımlayın, çünkü enum derleyici tarafından kontrol edilir.

C'ye özgü değil, ancak XOR operatörünü her zaman sevdim. Yapabileceği harika bir şey, "temp değeri olmadan takas":

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

Sonuç:

a = 1, b = 2

a = 2, b = 1

Bkz "C Gizli özelliklerini" sorusuna.

container_ofÖrneğin listelerde kullanılan kavramını seviyorum . Temel olarak, belirtmeniz gerekmez nextvelast listede olacak her bir yapı için alan . Bunun yerine, liste yapısı başlığını gerçek bağlantılı öğelere eklersiniz.

include/linux/list.hGerçek hayattan örneklere bir göz atın .

Kullanıcı verileri işaretleyicilerinin kullanımı oldukça düzgün olduğunu düşünüyorum . Bugünlerde moda kaybetti. Çok fazla bir C özelliği değil, ancak C'de kullanımı oldukça kolay.

Ön derleyicinin kod üretmesine izin vermek için X-Makroları kullanıyorum . Hata değerlerini ve ilişkili hata dizelerini tek bir yerde tanımlamak için özellikle yararlıdırlar, ancak bunun ötesine geçebilirler.

Kod tabanımızın benzer bir numarası var

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

hata ayıklama modunda bellek sızıntılarının izlenmesini sağlar. Her zaman bunun harika olduğunu düşündüm.

Makrolarla eğlenceli:

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

Uygulamanın çalıştırılmasında aslında HW'nin ne için kullanıldığı hakkında C kodunun nasıl tamamen habersiz hale getirileceğine dair bir örnek. Main.c kurulumu yapar ve daha sonra serbest katman herhangi bir derleyici / kemer üzerine uygulanabilir. Ben biraz C kodu soyutlama için oldukça temiz olduğunu düşünüyorum, bu yüzden özel olmak için alamadım.

Buraya eksiksiz bir derleme örneği ekleme.

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

Boşlukları doldurun, böylece çıktıda ne merhaba ne de merhaba görünmez.
ans:fclose(stdout)