เคล็ดลับการเขียนโปรแกรม C ที่คุณชอบคืออะไร? [ปิด]

ตัวอย่างเช่นฉันเพิ่งเจอสิ่งนี้ในเคอร์เนล linux:

/ * บังคับให้เกิดข้อผิดพลาดในการคอมไพล์หากเงื่อนไขเป็นจริง * /
#define BUILD_BUG_ON (เงื่อนไข) ((โมฆะ) sizeof (ถ่าน [1 - 2 * !! (เงื่อนไข)]))

ดังนั้นในโค้ดของคุณหากคุณมีโครงสร้างบางอย่างที่ต้องมีให้พูดขนาดหลาย ๆ 8 ไบต์อาจเป็นเพราะข้อ จำกัด ของฮาร์ดแวร์คุณสามารถทำได้:

BUILD_BUG_ON ((sizeof (โครงสร้างของโครงสร้าง)% 8)! = 0);

และจะไม่คอมไพล์เว้นแต่ขนาดของ struct mystruct จะเป็นผลคูณของ 8 และถ้าเป็นผลคูณของ 8 จะไม่มีการสร้างโค้ดรันไทม์เลย

เคล็ดลับอีกประการหนึ่งที่ฉันรู้มาจากหนังสือ "Graphics Gems" ซึ่งอนุญาตให้ไฟล์ส่วนหัวเดียวสามารถประกาศและเริ่มต้นตัวแปรในโมดูลเดียวในขณะที่โมดูลอื่น ๆ ที่ใช้โมดูลนั้นเพียงแค่ประกาศเป็นภายนอกเท่านั้น

#ifdef DEFINE_MYHEADER_GLOBALS
# กำหนดทั่วโลก
# กำหนด INIT (x, y) (x) = (y)
#อื่น
#define GLOBAL extern
# กำหนด INIT (x, y)
#endif

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

ด้วยเหตุนี้รหัสที่กำหนด x และ somefunc จึงทำดังนี้

# กำหนด DEFINE_MYHEADER_GLOBALS
# รวม "the_above_header_file.h"

ในขณะที่รหัสที่ใช้ x และ somefunc () ทำ:

# รวม "the_above_header_file.h"

ดังนั้นคุณจะได้รับไฟล์ส่วนหัวหนึ่งไฟล์ที่ประกาศทั้งอินสแตนซ์ของ globals และฟังก์ชันต้นแบบที่ต้องการและการประกาศภายนอกที่เกี่ยวข้อง

ดังนั้นเทคนิคการเขียนโปรแกรม 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

ขอบคุณ John Carmack! xD

ฉันชอบใช้= {0};เพื่อเริ่มต้นโครงสร้างโดยไม่จำเป็นต้องเรียก memset

struct something X = {0};

สิ่งนี้จะเริ่มต้นสมาชิกทั้งหมดของโครงสร้าง (หรืออาร์เรย์) เป็นศูนย์ (แต่ไม่ใช่ไบต์ช่องว่างใด ๆ - ใช้ memset หากคุณต้องการให้เป็นศูนย์ด้วยเช่นกัน)

แต่คุณควรจะตระหนักถึงมีบางประเด็นที่มีขนาดใหญ่นี้โครงสร้างการจัดสรรแบบไดนามิก

หากเรากำลังพูดถึงเทคนิค c ที่ฉันชอบต้องเป็นอุปกรณ์ของ Duffสำหรับการปลดลูป! ฉันแค่รอโอกาสที่เหมาะสมที่จะมาให้ฉันใช้มันด้วยความโกรธ ...

ใช้ __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

ฉันชอบ "struct hack" ที่มีวัตถุขนาดไดนามิก ไซต์นี้อธิบายได้ดีเช่นกัน (แม้ว่าจะอ้างถึงเวอร์ชัน C99 ที่คุณสามารถเขียน "str []" เป็นสมาชิกตัวสุดท้ายของโครงสร้างได้) คุณสามารถสร้างสตริง "object" ดังนี้:

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รวมอยู่ในขนาดของ (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 vide-codec ทำ:

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 และ Evan Teran

ใช่เวลาคอมไพล์ยืนยันได้ดีเสมอไป นอกจากนี้ยังสามารถเขียนเป็น:

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

ฉันจะไม่เรียกมันว่าเคล็ดลับที่ชื่นชอบจริงๆเพราะฉันไม่เคยใช้มันมาก่อน แต่การพูดถึงอุปกรณ์ของ Duff ทำให้ฉันนึกถึงบทความนี้เกี่ยวกับการใช้ Coroutines ใน C มันทำให้ฉันหัวเราะได้เสมอ แต่ฉันแน่ใจว่ามันทำได้ มีประโยชน์บ้าง

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

ในขณะที่ (0); ไม่มีผลกระทบใด ๆ กับโปรแกรม แต่คอมไพเลอร์จะออกคำเตือนเกี่ยวกับ "สิ่งนี้ไม่ทำอะไรเลย" ซึ่งเพียงพอที่จะทำให้ฉันไปดูบรรทัดที่กระทำผิดและดูเหตุผลที่แท้จริงที่ฉันต้องการเรียกร้องความสนใจ

ฉันเป็นแฟนของ xor hacks:

สลับ 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 ทำงานได้ดี

Rusty ได้สร้างชุดเงื่อนไขการสร้างทั้งหมดในccanโปรดดูโมดูลการยืนยันการสร้าง:

#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 มาโดยตลอด สิ่งที่ยอดเยี่ยมอย่างหนึ่งที่ทำได้คือ "swap โดยไม่มีค่า 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);

ผลลัพธ์:

a = 1, b = 2

a = 2, b = 1

ดูคำถาม"คุณลักษณะที่ซ่อนอยู่ของ C"

ฉันชอบแนวคิดที่container_ofใช้เป็นตัวอย่างในรายการ โดยทั่วไปคุณไม่จำเป็นต้องระบุnextและlastฟิลด์สำหรับแต่ละโครงสร้างซึ่งจะอยู่ในรายการ แต่คุณต้องต่อท้ายส่วนหัวโครงสร้างรายการกับรายการที่เชื่อมโยงจริง

ดูinclude/linux/list.hตัวอย่างชีวิตจริง

ฉันคิดว่าการใช้ตัวชี้userdataนั้นค่อนข้างเรียบร้อย วันนี้แฟชั่นที่สูญเสียพื้น คุณสมบัติ C ไม่มากนัก แต่ใช้งานง่ายใน C

ฉันใช้X-Macrosเพื่อให้พรีคอมไพเลอร์สร้างโค้ด ซึ่งมีประโยชน์อย่างยิ่งสำหรับการกำหนดค่าข้อผิดพลาดและสตริงข้อผิดพลาดที่เกี่ยวข้องในที่เดียว แต่สามารถไปได้ไกลกว่านั้น

codebase ของเรามีเคล็ดลับคล้ายกับ

#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 ทำการตั้งค่าจากนั้นสามารถใช้เลเยอร์ฟรีบนคอมไพเลอร์ / arch ใด ๆ ฉันคิดว่ามันค่อนข้างเรียบร้อยสำหรับการแยกโค้ด 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)