C宏有什么用？

我已经写了一些C语言，而且我读得足够好，可以大致了解它的功能，但是每次遇到宏时，它都会使我完全失望。我最终不得不记住宏是什么，并在阅读时将其替换在脑海中。我遇到的那些直观易懂的东西总是像小的迷你函数，所以我一直想知道为什么它们不只是函数。

我可以理解需要在预处理器中为调试或跨平台构建定义不同的构建类型，但是定义任意替换的功能似乎仅对使本来就很难理解的语言有用。

为什么为C引入了如此复杂的预处理器？还有没有人有使用它的示例，这会让我理解为什么#debug样式的条件编译时，为什么它似乎仍然用于简单的目的以外的用途？

编辑：

阅读了许多答案后，我仍然听不懂。最常见的答案是内联代码。如果inline关键字不这样做，则它有充分的理由不这样做，或者实现需要修复。我不明白为什么需要一种完全不同的机制来表示“真正内联此代码”（除了在内联之前编写的代码）。我也不理解提到的想法，即“如果它太愚蠢而无法放入函数中”。当然，任何需要输入并产生输出的代码都最好放在函数中。我想我可能不明白，因为我不习惯于编写C的微观优化，但是预处理器感觉就像是解决一些简单问题的复杂解决方案。

我最终不得不记住宏是什么，并在阅读时将其替换在脑海中。

这似乎不能很好地反映宏的命名。我认为如果它是一个log_function_entry()宏，则不必仿真预处理器。

我遇到的那些直观易懂的东西总是像小的迷你函数，所以我一直想知道为什么它们不只是函数。

通常，它们应该是，除非它们需要对通用参数进行操作。

#define max(a,b) ((a)<(b)?(b):(a))

可以与任何<运算符一起使用。

宏不仅具有功能，还使您可以使用源文件中的符号执行操作。这意味着您可以创建一个新的变量名，或引用宏所在的源文件和行号。

在C99中，宏还允许您调用可变函数，例如 printf

#define log_message(guard,format,...) \
   if (guard) printf("%s:%d: " format "\n", __FILE__, __LINE__,__VA_ARGS_);

log_message( foo == 7, "x %d", x)

其中的格式类似于printf。如果警卫队为真，它将输出消息以及打印该消息的文件和行号。如果是函数调用，它将不知道您从中调用过的文件和行，而使用a则vaprintf需要更多的工作。

通过比较C使用宏的几种方式以及如何在中实现它们，该摘录大致总结了我对此的看法D。

从DigitalMars.com复制

早在C发明时，编译器技术就是原始的。在前端安装文本宏预处理器是添加许多强大功能的简单明了的方法。程序的日益庞大和复杂性表明，这些功能存在许多固有的问题。D没有预处理器；但D提供了更具扩展性的方法来解决相同的问题。

巨集

预处理器宏为NET添加了强大的功能和灵活性C。但是它们有一个缺点：

• 宏没有范围的概念。从定义到源末尾，它们都是有效的。他们对.h文件，嵌套代码等进行了广泛的修改。当#include对成千上万的宏定义行进行处理时，避免无意中的宏扩展成为问题。
• 调试器不知道宏。仅了解宏扩展而不了解宏本身的调试器会破坏尝试用符号数据调试程序的意图。
• 宏使得不可能对源代码进行标记化，因为先前的宏更改可以任意地重做标记。
• 宏的纯文本基础导致任意使用和不一致的用法，使使用宏的代码易于出错。（通过模板引入了一些解决此问题的尝试C++。）
• 宏仍被用来弥补语言表达能力的不足，例如头文件周围的“包装器”。

以下是宏的常用用法以及D中相应功能的枚举：

1. 定义文字常量：

   • 该C预处理方法

     #define VALUE 5
     

   • 该D路

     const int VALUE = 5;
     

2. 创建值或标志的列表：

   • 该C预处理方法

     int flags:
     #define FLAG_X  0x1
     #define FLAG_Y  0x2
     #define FLAG_Z  0x4
     ...
     flags |= FLAG_X;
     

   • 该D路

     enum FLAGS { X = 0x1, Y = 0x2, Z = 0x4 };
     FLAGS flags;
     ...
     flags |= FLAGS.X;
     

3. 设置函数调用约定：

   • 该C预处理方法

     #ifndef _CRTAPI1
     #define _CRTAPI1 __cdecl
     #endif
     #ifndef _CRTAPI2
     #define _CRTAPI2 __cdecl
     #endif
     
     int _CRTAPI2 func();
     

   • 该D路

     可以在块中指定调用约定，因此无需为每个函数进行更改：

     extern (Windows)
     {
         int onefunc();
         int anotherfunc();
     }
     

4. 简单的通用编程：

   • 该C预处理方法

     根据文本替换选择要使用的功能：

     #ifdef UNICODE
     int getValueW(wchar_t *p);
     #define getValue getValueW
     #else
     int getValueA(char *p);
     #define getValue getValueA
     #endif
     

   • 该D路

     D 启用作为其他符号别名的符号声明：

     version (UNICODE)
     {
         int getValueW(wchar[] p);
         alias getValueW getValue;
     }
     else
     {
         int getValueA(char[] p);
         alias getValueA getValue;
     }
     

DigitalMars网站上还有更多示例。

它们是C语言之上的一种编程语言（一种简单的语言），因此对于在编译时进行元编程非常有用……换句话说，您可以编写宏代码，从而以更少的行和时间生成C代码。直接用C编写

它们对于编写“多态”或“重载”的“函数式”表达式也非常有用。例如，最大宏定义为：

#define max(a,b) ((a)>(b)?(a):(b))

对任何数字类型都有用；在C语言中，您无法编写：

int max(int a, int b) {return a>b?a:b;}
float max(float a, float b) {return a>b?a:b;}
double max(double a, double b) {return a>b?a:b;}
...

即使您想要，因为您不能重载函数。

更不用说条件编译和包含文件（它们也是宏语言的一部分）...

宏允许某人在编译期间修改程序行为。考虑一下：

• C常数允许在开发时修正程序行为
• C变量允许在执行时修改程序行为
• C宏允许在编译时修改程序行为

在编译时，这意味着未使用的代码甚至都不会进入二进制文件，并且只要将其与宏预处理器集成在一起，构建过程就可以修改值。示例：make ARCH = arm（假定转发宏定义为cc -DARCH = arm）

简单示例：（从glibclimits.h中，定义long的最大值）

#if __WORDSIZE == 64
#define LONG_MAX 9223372036854775807L
#else
#define LONG_MAX 2147483647L
#endif

如果我们要编译32位或64位，则在编译时进行验证（使用#define __WORDSIZE）。使用multilib工具链时，使用参数-m32和-m64可能会自动更改位大小。

（要求POSIX版本）

#define _POSIX_C_SOURCE 200809L

在编译期间请求POSIX 2008支持。标准库可能支持许多（不兼容）标准，但是使用此定义，它将提供正确的函数原型（例如：getline（），no gets（）等）。如果该库不支持该标准，则可能在编译时发出#error，而不是在执行期间崩溃。

（硬编码路径）

#ifndef LIBRARY_PATH
#define LIBRARY_PATH "/usr/lib"
#endif

在编译期间定义一个硬代码目录。例如，可以使用-DLIBRARY_PATH = / home / user / lib进行更改。如果那是const char *，那么在编译过程中如何配置它？

（pthread.h，编译时的复杂定义）

# define PTHREAD_MUTEX_INITIALIZER \
  { { 0, 0, 0, 0, 0, 0, { 0, 0 } } }

可能会声明原本不会被简化的大块文本（总是在编译时）。使用函数或常量（在编译时）无法执行此操作。

为了避免真正复杂化并避免建议不良的编码风格，我不会提供在不同，不兼容的操作系统中编译的代码示例。为此，请使用交叉构建系统，但是应该清楚的是，预处理器允许在没有构建系统帮助的情况下进行操作，而不会由于缺少接口而中断编译。

最后，考虑条件编译在嵌入式系统上的重要性，因为嵌入式系统上的处理器速度和内存有限，并且系统非常异构。

现在，如果您提出要求，是否可以将所有宏常量定义和函数调用替换为正确的定义？答案是肯定的，但是不会仅仅消除编译期间更改程序行为的需要。仍然需要预处理器。

请记住，宏（和预处理器）来自C的早期。它们曾经是执行内联“函数”的唯一方法（因为inline是一个非常新的关键字），但它们仍然是强制内联的唯一方法。

另外，宏是您完成诸如在编译时将文件和行插入字符串常量之类的技巧的唯一方法。

如今，通过更新的机制可以更好地处理宏曾经是唯一的方法。但是他们仍然时有发生。

除了内联以提高效率和条件编译外，宏还可以用于提高低级C代码的抽象级别。C并没有真正使您与内存和资源管理的本质细节以及数据的精确布局相隔离，它支持非常有限形式的信息隐藏和其他用于管理大型系统的机制。使用宏，您不再局限于仅使用C语言的基本构造：您可以定义自己的数据结构和编码构造（包括类和模板！），同时仍然名义上编写C！

预处理程序宏实际上提供了在编译时执行的图灵完备语言。在C ++方面，这是令人印象深刻（且稍有些令人恐惧）的示例之一：Boost预处理程序库使用C99 / C ++ 98预处理程序来构建（相对）安全的编程结构，然后将其扩展为任何基础声明和代码。您输入的是C还是C ++。

在实践中，当您不愿意使用更安全的语言来使用高级构造时，建议将预处理器编程作为最后的选择。但是有时候知道自己的后背靠在墙上并且黄鼠狼正在关闭...

从计算机愚蠢：

我已经在许多用于UNIX的免费软件游戏程序中看到以下代码摘录：

/ *
*位值。
* /
#define BIT_0 1
#define BIT_1 2
#define BIT_2 4
#define BIT_3 8
#define BIT_4 16
#define BIT_5 32
#define BIT_6 64
#define BIT_7 128
#define BIT_8 256
#define BIT_9 512
#define BIT_10 1024
#define BIT_11 2048
＃定义BIT_12 4096
＃定义BIT_13 8192
＃定义BIT_14 16384
＃定义BIT_15 32768
＃定义BIT_16 65536
＃定义BIT_17 131072
＃定义BIT_18 262144
＃定义BIT_19 524288
＃定义BIT_20 1048576
＃定义BIT_21 2097152
#define BIT_22 4194304
#define BIT_23 8388608
#define BIT_24 16777216
#define BIT_25 33554432
#define BIT_26 67108864
#define BIT_27 134217728
#define BIT_28 268435456
#define BIT_29 536870912
#define BIT_30 1073741824
#define

一个更简单的方法是：

#define BIT_0 0x00000001
#define BIT_1 0x00000002
#define BIT_2 0x00000004
#define BIT_3 0x00000008
#define BIT_4 0x00000010
...
#define BIT_28 0x10000000
#define BIT_29 0x20000000
#define BIT_30 0x40000000
#define BIT_31 0x80000000

还有一种更简单的方法是让编译器进行计算：

#define BIT_0（1）
#define BIT_1（1 << 1）
#define BIT_2（1 << 2）
#define BIT_3（1 << 3）
#define BIT_4（1 << 4）
...
#define BIT_28（1 << 28）
#define BIT_29（1 << 29）
#define BIT_30（1 << 30）
#define BIT_31（1 << 31）

但是为什么要麻烦定义32个常量呢？C语言还具有参数化的宏。您真正需要的是：

＃定义BIT（x）（1 <<（x））

无论如何，我想知道编写原始代码的人是使用计算器还是只是将其全部计算在纸上。

那只是宏的一种可能用途。

我将补充说的话。

因为宏可以处理文本替换，所以它们使您可以做一些非常有用的事情，而这些是使用函数无法实现的。

在某些情况下，宏可能会真正有用：

/* Get the number of elements in array 'A'. */
#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0]))

这是一个非常流行且经常使用的宏。例如，当您需要遍历数组时，这非常方便。

int main(void)
{
    int a[] = {1, 2, 3, 4, 5};
    int i;
    for (i = 0; i < ARRAY_LENGTH(a); ++i) {
        printf("a[%d] = %d\n", i, a[i]);
    }
    return 0;
}

在这里，是否其他程序员a在decleration中再添加五个元素并不重要。该for-loop将始终通过所有元素进行迭代。

C库用于比较内存和字符串的函数很难使用。

你写：

char *str = "Hello, world!";

if (strcmp(str, "Hello, world!") == 0) {
    /* ... */
}

要么

char *str = "Hello, world!";

if (!strcmp(str, "Hello, world!")) {
    /* ... */
}

检查是否str指向"Hello, world"。我个人认为这两种解决方案看起来都非常难看和令人困惑（尤其是!strcmp(...)）。

这是一些人（包括I）在需要使用strcmp/比较字符串或内存时使用的两个简洁的宏memcmp：

/* Compare strings */
#define STRCMP(A, o, B) (strcmp((A), (B)) o 0)

/* Compare memory */
#define MEMCMP(A, o, B) (memcmp((A), (B)) o 0)

现在，您可以编写如下代码：

char *str = "Hello, world!";

if (STRCMP(str, ==, "Hello, world!")) {
    /* ... */
}

这是很多清晰的意图！

这是宏用于功能无法完成的事情的情况。宏不应该用来代替函数，但是它们还有其他很好的用途。

宏真正发光的一种情况是使用它们进行代码生成时。

我曾经在一个旧的C ++系统上工作，该系统使用插件系统以他自己的方式将参数传递给插件（使用自定义的类似地图的结构）。一些简单的宏被用来处理这个奇怪的问题，并允许我们在插件中使用带有正常参数的真实C ++类和函数而没有太多问题。宏生成的所有粘合代码。

给定问题中的注释，您可能不完全理解调用函数会带来相当大的开销。参数和键寄存器可能必须在进库时复制到堆栈中，而在出库时将其展开。对于较旧的Intel芯片尤其如此。宏允许程序员（几乎）保留函数的抽象，但避免了函数调用的昂贵开销。内联关键字是建议性的，但是编译器可能并不总是正确。“ C”的荣耀和危险在于，您通常可以按自己的意愿弯曲编译器。

在您的日常工作中，这种微优化（避免函数调用）在日常应用程序编程中通常会更糟，然后变得毫无用处，但是如果您编写的是由操作系统内核调用的对时间要求严格的函数，则它可以产生巨大的变化。

与常规函数不同，您可以在宏中控制流（如果，为，...，……）。这是一个例子：

#include <stdio.h>

#define Loop(i,x) for(i=0; i<x; i++)

int main(int argc, char *argv[])
{
    int i;
    int x = 5;
    Loop(i, x)
    {
        printf("%d", i); // Output: 01234
    } 
    return 0;
} 

这对于内联代码和避免函数调用开销很有用。如果要稍后更改行为而无需编辑很多位置，也可以使用它。它对复杂的事情没有用，但是对于要内联的简单代码行来说，也不错。

通过利用C预处理程序的文本操作，可以构造C等效的多态数据结构。使用这种技术，我们可以构造一个可靠的原始数据结构工具箱，该结构可以在任何C程序中使用，因为它们利用了C语法而不是任何特定实现的细节。

有关如何使用宏来管理数据结构的详细说明，请参见此处-http://multi-core-dump.blogspot.com/2010/11/interesting-use-of-c-macros-polymorphic.html

宏使您摆脱粘贴粘贴的片段，而这些片段是您无法以其他任何方式消除的。

例如（实际代码，VS 2010编译器的语法）：

for each (auto entry in entries)
{
        sciter::value item;
        item.set_item("DisplayName",    entry.DisplayName);
        item.set_item("IsFolder",       entry.IsFolder);
        item.set_item("IconPath",       entry.IconPath);
        item.set_item("FilePath",       entry.FilePath);
        item.set_item("LocalName",      entry.LocalName);
        items.append(item);
    }

在这里，您可以将同名的字段值传递给脚本引擎。这是复制粘贴的吗？是。DisplayName用作脚本的字符串和编译器的字段名称。那不好吗？是。如果您重构代码并重命名LocalName为RelativeFolderName（就像我所做的那样），而忘记对字符串做同样的事情（就像我所做的那样），那么脚本将以您不期望的方式工作（实际上，在我的示例中，它取决于您是否忘记了在单独的脚本文件中重命名该字段，但是如果该脚本用于序列化，那将是100％的错误）。

如果为此使用宏，则将没有空间容纳该错误：

for each (auto entry in entries)
{
#define STR_VALUE(arg) #arg
#define SET_ITEM(field) item.set_item(STR_VALUE(field), entry.field)
        sciter::value item;
        SET_ITEM(DisplayName);
        SET_ITEM(IsFolder);
        SET_ITEM(IconPath);
        SET_ITEM(FilePath);
        SET_ITEM(LocalName);
#undef SET_ITEM
#undef STR_VALUE
        items.append(item);
    }

不幸的是，这为其他类型的错误打开了一扇门。您可以输入宏，但不会出现损坏的代码，因为编译器不会显示所有预处理后的样子，您可能会打错字。其他人可能使用相同的名称（这就是为什么我使用尽快“释放”宏的原因#undef）。因此，请明智地使用它。如果您看到另一种摆脱复制粘贴的代码的方法（例如函数），请使用该方法。如果您发现使用宏删除带有复制粘贴的代码是不值得的，请保留复制粘贴的代码。

显而易见的原因之一是，通过使用宏，代码将在编译时进行扩展，从而获得了伪函数调用，而没有调用开销。

否则，您也可以将其用于符号常量，这样就不必在多个地方编辑相同的值来更改一件小事情。

宏..用于当您的＆＃（* $＆编译器拒绝内联某些东西时。

那应该是励志海报，不是吗？

认真地说，是Google预处理程序滥用（您可能会在＃1结果中看到类似的SO问题）。如果编写的宏超出了assert（）的功能，通常会尝试查看编译器是否实际上内联了类似的函数。

其他人会反对使用#if进行条件编译..他们希望您：

if (RUNNING_ON_VALGRIND)

而不是

#if RUNNING_ON_VALGRIND

..用于调试目的，因为您可以在调试器中看到if（）但看不到#if。然后我们进入#ifdef vs #if。

如果其代码行数少于10行，请尝试内联它。如果无法内联，请尝试对其进行优化。如果它太愚蠢而不能用作函数，请创建一个宏。

虽然我不是宏的忠实拥护者，并且不再倾向于编写太多C，但根据我当前的任务，类似这样的事情（显然可能会有一些副作用）很方便：

#define MIN(X, Y)  ((X) < (Y) ? (X) : (Y))

现在，我已经几年没有写过类似的东西了，但是那样的“函数”遍及了我职业生涯早期维护的代码。我想扩展可以认为很方便。

关于宏之类的功能，例如，我没有看到任何人这么提：

#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))

通常，由于许多原因，建议避免使用不必要的宏，因为主要是可读性。所以：

什么时候应该在功能上使用这些？

几乎永远不会，因为还有一个更具可读性的替代方法inline，请参见https://www.greenend.org.uk/rjk/tech/inline.html 或http://www.cplusplus.com/articles/2LywvCM9/（第二篇链接是一个C ++页面，但据我所知这一点适用于c编译器。

现在，稍有不同是宏是由预处理器处理的，而内联是由编译器处理的，但是现在没有实际的区别。

什么时候适合使用这些？

对于小功能（最多两个或三个衬管）。目的是在程序运行时获得一些优势，因为宏（和内联函数）之类的函数是在预处理（或内联的情况下进行编译）期间进行的代码替换，而不是存在于内存中的实际函数，因此没有函数调用的开销（链接页面中有更多详细信息）。