您最喜欢的C编程技巧是什么？[关闭]

例如，我最近在linux内核中遇到了这个问题：

/ *如果条件为真，则强制执行编译错误* /
＃定义BUILD_BUG_ON（条件）（（无效）sizeof（字符[1-2 * !!（条件）]））

因此，在您的代码中，如果您具有某种必须为8个字节大小的倍数的结构，可能由于某些硬件限制，您可以执行以下操作：

BUILD_BUG_ON（（sizeof（struct mystruct）％8）！= 0）;

除非struct mystruct的大小是8的倍数，否则它不会编译；如果它是8的倍数，则根本不会生成任何运行时代码。

我知道的另一个技巧是从“ Graphics Gems”一书中获得的，该书允许单个头文件在一个模块中声明和初始化变量，而在其他使用该模块的模块中，仅将其声明为externs。

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
＃定义INIT（x，y）（x）=（y）
＃其他
#define GLOBAL extern
＃定义INIT（x，y）
＃万一

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”

因此，您将获得一个标头文件，该标头文件声明了需要它们的全局实例和函数原型的实例，以及相应的extern声明。

那么，您最喜欢的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技巧，我最喜欢的必须是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

我喜欢具有动态大小的对象的“结构黑客”。该站点也对此进行了很好的解释（尽管它们引用的是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）的大小，再加上“世界你好”的长度，加上1堆（因为STR 1被列入的sizeof（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以指向这样的表，并根据需要对其进行重新引导（在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的设备使我想起了这篇文章，用C语言实现协程。有用一些时间。

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

while（0）; 对程序没有影响，但是编译器将发出有关“此操作无效”的警告，这足以使我了解有问题的行，然后查看想要引起注意的真正原因。

我是xor hack的粉丝：

交换2个没有第三个临时指针的指针：

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

或者我真的很喜欢只有一个指针的异或链表。（http://zh.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中生成了一整套构建条件，请查看build assert模块：

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

实际的标头中还有许多其他有用的宏，这些宏很容易就位。

我尽一切努力通过主要坚持使用内联函数来抵制黑暗面（和预处理程序滥用），但是我确实喜欢像您所描述的那样聪明，有用的宏。

关于这类东西的两本很好的原始书是“编程和编写固态代码的实践”。其中一个（我不记得是哪个）说：最好在可能的地方使用#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代码完全不了解硬件在运行该应用程序时实际使用了什么。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");

填写空格，使hello和hi都不会出现在输出中。
回答：fclose(stdout)