Thủ thuật lập trình C yêu thích của bạn là gì? [đóng cửa]

Ví dụ, gần đây tôi đã bắt gặp điều này trong kernel linux:

/ * Buộc lỗi biên dịch nếu điều kiện là đúng * /
#define BUILD_BUG_ON (điều kiện) ((void) sizeof (char [1 - 2 * !! (điều kiện)]))

Vì vậy, trong mã của bạn, nếu bạn có một số cấu trúc phải có, giả sử có nhiều kích thước 8 byte, có thể do một số hạn chế về phần cứng, bạn có thể thực hiện:

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

và nó sẽ không biên dịch trừ khi kích thước của struct struct struct là bội số của 8 và nếu nó là bội số của 8, thì không có mã thời gian chạy nào được tạo ra cả.

Một mẹo khác mà tôi biết là từ cuốn sách "Đồ họa đá quý" cho phép một tệp tiêu đề duy nhất để khai báo và khởi tạo các biến trong một mô-đun trong khi trong các mô-đun khác sử dụng mô-đun đó, chỉ đơn thuần khai báo chúng là externs.

#ifdef DEFINE_MYHEADER_GLOBALS
#define TOÀN CẦU
#define INIT (x, y) (x) = (y)
#else
#define bên ngoài TOÀN CẦU
#define INIT (x, y)
#endif

TOÀN CẦU int INIT (x, 0);
TOÀN CẦU int somefunc (int a, int b);

Cùng với đó, mã xác định x và somefunc thực hiện:

#define DEFINE_MYHEADER_GLOBALS
#inc loại "the_above_header_file.h"

trong khi mã chỉ đơn thuần sử dụng x và somefunc () thì:

#inc loại "the_above_header_file.h"

Vì vậy, bạn nhận được một tệp tiêu đề khai báo cả hai phiên bản toàn cầu và nguyên mẫu hàm khi cần và các khai báo bên ngoài tương ứng.

Vì vậy, các thủ thuật lập trình C yêu thích của bạn dọc theo những dòng đó là gì?

C99 cung cấp một số thứ thực sự thú vị bằng cách sử dụng mảng ẩn danh:

Loại bỏ các biến vô nghĩa

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

trở thành

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

Vượt qua một lượng đối số

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

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

Danh sách liên kết tĩnh

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

Bất kỳ tôi chắc chắn nhiều kỹ thuật tuyệt vời khác tôi không nghĩ đến.

Trong khi đọc mã nguồn Quake 2, tôi đã nghĩ ra một thứ như thế này:

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

(ít nhiều, tôi không có mã để kiểm tra ngay bây giờ).

Kể từ đó, một thế giới mới của việc sử dụng sáng tạo bộ tiền xử lý đã mở ra trước mắt tôi. Tôi không còn chỉ bao gồm các tiêu đề, mà toàn bộ các đoạn mã bây giờ và sau đó (nó cải thiện khả năng sử dụng lại rất nhiều) :-p

Cảm ơn John Carmack! xD

Tôi thích sử dụng = {0};để khởi tạo cấu trúc mà không cần gọi bộ nhớ.

struct something X = {0};

Điều này sẽ khởi tạo tất cả các thành viên của struct (hoặc mảng) về 0 (nhưng không phải bất kỳ byte đệm nào - sử dụng bộ nhớ nếu bạn cũng cần phải làm như vậy).

Nhưng bạn nên lưu ý rằng có một số vấn đề với điều này đối với các cấu trúc lớn, được phân bổ động .

Nếu chúng ta đang nói về các thủ thuật c, yêu thích của tôi phải là Thiết bị của Duff để không kiểm soát vòng lặp! Tôi chỉ đang chờ cơ hội thích hợp để cùng tôi thực sự sử dụng nó trong sự tức giận ...

sử dụng __FILE__và __LINE__để gỡ lỗi

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

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

Khi một người bạn đời của tôi và tôi xác định lại trở về để tìm một lỗi tham nhũng ngăn xếp khó khăn.

Cái gì đó như:

#define return DoSomeStackCheckStuff, return

Tôi thích "struct hack" vì có một đối tượng có kích thước động. Trang web này cũng giải thích nó khá tốt (mặc dù họ đề cập đến phiên bản C99 nơi bạn có thể viết "str []" là thành viên cuối cùng của một cấu trúc). bạn có thể tạo một chuỗi "đối tượng" như thế này:

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;

Ở đây, chúng tôi đã phân bổ cấu trúc của loại X trên heap có kích thước của một int (cho len), cộng với độ dài của "hello world", cộng với 1 (kể từ str 1 được bao gồm trong sizeof (X).

Nó thường hữu ích khi bạn muốn có một "tiêu đề" ngay trước một số dữ liệu có độ dài thay đổi trong cùng một khối.

Mã hướng đối tượng với C, bằng cách mô phỏng các lớp.

Đơn giản chỉ cần tạo một cấu trúc và một tập hợp các hàm lấy một con trỏ tới cấu trúc đó làm tham số đầu tiên.

Thay vì

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

Sử dụng

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

Sử dụng một thủ thuật vĩ mô ngu ngốc để làm cho các định nghĩa hồ sơ dễ dàng hơn để duy trì.

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

Để tạo một biến chỉ đọc trong tất cả các mô-đun ngoại trừ biến được khai báo trong:

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

Dịch chuyển bit chỉ được xác định tối đa là lượng dịch chuyển là 31 (trên số nguyên 32 bit) ..

Bạn sẽ làm gì nếu bạn muốn có một ca làm việc được tính toán cần phải làm việc với các giá trị ca cao hơn? Đây là cách The vide-codec thực hiện nó:

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

Hoặc dễ đọc hơn nhiều:

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

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

Thực hiện nhiệm vụ theo cách hiển thị ở trên nhanh hơn nhiều so với sử dụng một nhánh như thế này:

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

Khai báo mảng con trỏ tới các hàm để thực hiện các máy trạng thái hữu hạn.

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

Ưu điểm dễ chịu nhất là đơn giản để buộc mỗi kích thích / trạng thái kiểm tra tất cả các đường dẫn mã.

Trong một hệ thống nhúng, tôi thường ánh xạ ISR để trỏ đến một bảng như vậy và chỉnh sửa nó khi cần thiết (bên ngoài ISR).

Một "mẹo" tiền xử lý hay khác là sử dụng ký tự "#" để in các biểu thức gỡ lỗi. Ví dụ:

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

chỉnh sửa: mã dưới đây chỉ hoạt động trên C ++. Cảm ơn smcameron và Evan Teran.

Vâng, thời gian biên dịch khẳng định luôn luôn tuyệt vời. Nó cũng có thể được viết là:

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

Tôi thực sự sẽ không gọi nó là một trò lừa ưa thích, vì tôi chưa bao giờ sử dụng nó, nhưng việc nhắc đến Thiết bị của Duff đã nhắc nhở tôi về bài viết này về việc triển khai Coroutines trong C. Nó luôn mang đến cho tôi một tiếng cười, nhưng tôi chắc chắn rằng nó có thể có ích một thời gian

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

Trong khi (0); không có tác dụng đối với chương trình, nhưng trình biên dịch sẽ đưa ra cảnh báo về "điều này không có gì", điều đó đủ để khiến tôi phải nhìn vào dòng vi phạm và sau đó xem lý do thực sự tôi muốn gọi sự chú ý đến nó.

Tôi là một fan hâm mộ của hack xor:

Hoán đổi 2 con trỏ không có con trỏ tạm thời thứ ba:

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

Hoặc tôi thực sự thích danh sách liên kết xor chỉ với một con trỏ. (http://en.wikipedia.org/wiki/XOR_linked_list)

Mỗi nút trong danh sách được liên kết là Xor của nút trước và nút tiếp theo. Để di chuyển về phía trước, địa chỉ của các nút được tìm thấy theo cách sau:

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

Vân vân.

hoặc để di chuyển ngược:

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;

Vân vân.

Mặc dù không hữu ích lắm (bạn không thể bắt đầu di chuyển từ một nút tùy ý) tôi thấy nó rất tuyệt.

Cuốn này xuất phát từ cuốn sách 'Đủ dây để tự bắn vào chân mình':

Trong tiêu đề khai báo

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

Trong mã của bạn, nơi kiểm tra báo cáo ví dụ:

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

Do / while giúp trong trường hợp nội dung của macro mở rộng thành nhiều câu lệnh.

Câu lệnh sẽ chỉ được in nếu cờ '-D RELEASE' cho trình biên dịch không được sử dụng.

Bạn có thể sau đó ví dụ. chuyển cờ đến tệp thực hiện của bạn, v.v.

Không chắc cách thức hoạt động trong windows nhưng trong * nix nó hoạt động tốt

Rusty thực sự đã tạo ra một tập hợp các điều kiện xây dựng trong ccan , hãy kiểm tra mô đun khẳng định xây dựng:

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

Có rất nhiều macro hữu ích khác trong tiêu đề thực tế, dễ dàng thả vào vị trí.

Tôi cố gắng, với tất cả khả năng của mình để chống lại sự lôi kéo của mặt tối (và lạm dụng tiền xử lý) bằng cách chủ yếu bám vào các hàm nội tuyến, nhưng tôi thích các macro thông minh, hữu ích như những gì bạn mô tả.

Hai cuốn sách nguồn tốt cho loại công cụ này là Thực hành lập trình và viết mã rắn . Một trong số họ (tôi không nhớ là gì) nói: Thích enum hơn #define nơi bạn có thể, bởi vì enum được trình biên dịch kiểm tra.

Không cụ thể với C, nhưng tôi luôn thích toán tử XOR. Một điều thú vị mà nó có thể làm là "trao đổi mà không có giá trị tạm thời":

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

Kết quả:

a = 1, b = 2

a = 2, b = 1

Xem câu hỏi "Tính năng ẩn của C" .

Tôi thích khái niệm container_ofđược sử dụng ví dụ trong danh sách. Về cơ bản, bạn không cần chỉ định nextvà lastcác trường cho từng cấu trúc sẽ có trong danh sách. Thay vào đó, bạn nối tiêu đề cấu trúc danh sách vào các mục được liên kết thực tế.

Có một cái nhìn về include/linux/list.hcác ví dụ thực tế.

Tôi nghĩ rằng việc sử dụng con trỏ userdata là khá gọn gàng. Một thời trang mất đất ngày nay. Đây không phải là một tính năng C nhưng khá dễ sử dụng trong C.

Tôi sử dụng X-Macros để cho phép trình biên dịch trước tạo mã. Chúng đặc biệt hữu ích để xác định các giá trị lỗi và các chuỗi lỗi liên quan ở một nơi, nhưng chúng có thể vượt xa điều đó.

Cơ sở mã của chúng tôi có một mẹo tương tự như

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

cho phép theo dõi rò rỉ bộ nhớ trong chế độ gỡ lỗi. Tôi luôn nghĩ rằng điều này là mát mẻ.

Vui với macro:

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

Dưới đây là một ví dụ về cách làm cho mã C hoàn toàn không biết về những gì thực sự được sử dụng của CTNH để chạy ứng dụng. Main.c thực hiện thiết lập và sau đó lớp miễn phí có thể được thực hiện trên bất kỳ trình biên dịch / vòm nào. Tôi nghĩ rằng nó khá gọn gàng để trừu tượng hóa mã C một chút, vì vậy nó không phải là đặc biệt.

Thêm một ví dụ tổng hợp đầy đủ ở đây.

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

Điền vào chỗ trống để không chào và cũng không xuất hiện trong đầu ra.
ans:fclose(stdout)