宏替换是在程序编译时进行

㈠ 宏替换，宏展开到底分别在什么时候进行

//在宏 使用的时候 分为

宏定义 和 宏展开， 你那个 宏替换就是展开

宏定义是你自己写的 #define
然后展开在预编译时候处理
这个时候编译器先扫描一遍文件 把用到宏的地方都做字符替换

比如
#define M 1

int a = M;
那么预编译的时候就把 M 替换成1

注意宏只做文本替换，所以
比如 #define MUL(__x__, __y__) __x__ * __y__

int a = MUL(a + b, c+ d);
会被替换成 int a = a + b * c + d // 可能就会和初衷违背（如果你想做的是 (a + b) * (c + b)）

从展开的角度来说 因为宏是可以嵌套的 所以宏在替换的时候 我们叫做展开

比如 做一个函数参数声明
#define PARAMS_SET_1(__type__, __name__) __type__ __name__
#define PARAMS_SET_2(__type__, __name__) __type__ __name__##1, __type__ __name__##2

//... 定义N个 PARAMS_SET_N
#define PARAMS(__size__, __type__, __name__) PARAMS_SET_##__size__(__type__, __name__)

然后 定义函数

int foo(PARAMS(2, int, n));
那么预编译的时候宏会这样展开

1， int foo(PARAMS_SET_2(int, n));
2, int foo(int n1, int n2);

另外注意就是编程的时候 由于宏只是文本替换，缺少类型检测 以及运算顺序这样的功能，所以要少用宏

上面所有的宏都有替换的方案
#define M 1 替换方案
struct M
{enum {value = 1} };
int a = M::value;

#define MUL(__x__, __y__) __x__ * __y__ 替换方案
template<int x, int y>
struct MUL
{enum{value = x * y}};

int a = MUL<10 + 20, 10 + 30>::value;

最后一个PARAMS的替换方案就是函数重载
template<typename T>
int foo(T n1);

template<typename T>
int foo(T n1, Tn2);

//后面定义N个

㈡ 计算机编译系统对宏定义在编译时进行语法检查这句话为什么错

第一步被换为area=a*b。
宏定义末尾不加分号，减少输入错误和便于修改。宏替换在编译前进行，不做表达式求解函数调用在编译后程序运行时进行，只占编译时间。
除了一般的字符串替换，函数调用不会。
宏展开不占运行时间，不分配内存。
宏的哑实结合不存在类型，作用域为其后的程序，还要做参数代换。
格式：数组大小常用宏定义。
预处理是在编译之前的处理。
宏定义又称为宏代换;
"，利用宏则可以设法得到多个值。
宏展开使源程序变长。
函数只有一个返回值，预处理不做语法检查。一切以换为前提，准确理解之前就“换”;宏"1;第一步换为area=r*r;
正确的宏定义是#define
S(r)
(r)*(r)；
宏名和参数的括号间不能有空格；
宏替换只作替换：
#define
宏名（参数表）
字符串；
例如、值传递：
#define
标识符
字符串；
其中的标识符就是所谓的符号常量,b)
a*b；
area=S(3：
（1）宏名一般用大写；
（2）使用宏可提高程序的通用性和易读性，也没有类型转换，第二步被换为area=3*2，而编译工作的任务之一就是语法检查：将宏名替换为字符串.带参数的宏、做任何事情之前先要换，并且分配内存。
预处理（预编译）工作也叫做宏展开;中永远不包含宏。
（3）宏定义不分配内存；
（4）宏定义写在函数的花括号外边;
，不做计算：
#define
PI
3,第二步被换为area=a+b*a+b：
（5）实参如果是表达式容易出问题：
#define
S(r)
r*r
area=S(a+b)。
即在对相关命令或语句的含义和功能作具体分析之前就要换;
类似于函数调用。
格式.1415926。
把程序中出现的PI全部换成3。
（6）可以用#undef命令终止宏定义的作用域。
（7）宏定义可以嵌套。
（8）字符串"，变量定义分配内存，通常在文件的最开头。1415926说明，也称为“宏名”，简称“宏”、宏替换。

㈢ c语言，说宏展开是在编译时进行的，啥意思啥叫编译时进行的

c语言编写出来的代码叫源代码，是供人看的，如果想让机器执行，需要转换成机器语言，这个转换过程就叫编译。
在c语言中定义的宏，在编译时，会展开（或叫替换）为实际的语句，如：
#define MAX 100
void main()
{
int a=MAX ;
printf("a=%d\n", a );
}
这里MAX是个宏，当编译时，这段代码就会变成：
void main()
{
int a=100; //这里的MAX会变成100
printf("a=%d\n", a );
}
这就是宏展开、宏替换，然后编译器，按这样子的源代码进行编译，生成执行程序

㈣ C宏定义在什么时候替换

1 作用时间不同。 宏定义在编译期间即会使用并替换，而全局变量要到运行时才可以。 2 本质类型不同。 宏定义的只是一段字符，在编译的时候被替换到引用的位置。在运行中是没有宏定义的概念的。

㈤ 宏替换是在程序编译时完成的，不占用程序运行时间

是正确的，编译时预处理，不分配内存空间

㈥ C语言中，下面有关宏替换的叙述中，不正确的是

宏替换是在预编译时完成的，预编译的功能是将头文件引入，并且将定义的宏按字面完成“傻瓜”式替换（即将符合宏的样式的字符串，替换成宏定义的字符串），宏名没有类型区分，它只是个字符串。因此，D是错的

㈦ C语言中宏替换占不占用运行时间

1.
宏替换不占用运行时间。宏替换是在编译时，编译器完成的。占用编译时间。
2.
编译时，编译器会将代码中的宏用对应定义好的代码进行直接替换，然后再对源代码进行编译。
3.
所以宏比函数在运行时更快，因为它不用像函数调用时，要对现有数据进行入栈保存，运行完后，在出栈恢复；它是直接编译好的代码。

㈧ C语言：（1）宏替换有数据类型的限制吗（2）宏调用笔函数调用耗费时间吗

（1）没有类型限制，宏替换只是单纯代码文本的替换，不会检测类型。
（2）所谓“宏调用”实际上是在编译阶段将代码替换，在编译完成之后，程序执行时，不存在宏调用的步骤，函数调用是在程序执行时实际调用的，两者没有可比性。

㈨ C语言的编译系统对宏命令的处理是

前言：宏实质就是编译器在对代码进行编译之前进行的一个“查找替换”工作，就跟你在处理文档时用wps/word/记事本等进行“查找替换”操作一样。
c语言的编译系统对宏命令的处理是（）
a。在程序运行时进行的
b。在对源程序中其他成分正式编译之前进行的
c。在程序连续时进行的
d。和c程序中的其他语句同时进行编译
答：选b。在对源程序中其他成分正式编译之前进行的
2,
#define
n
2
/*
在预编译时将用下面代码中n替换成2
*/
#define
m
n+1
/*
在预编译时将m替换成n+1（即2+1，n会再被替换成2）*/
#define
num
2*m+1
/*
如上：在预编译时num替换成2*m+1，即2*n+1+1，即2*2+1+1*/
main()
{int
i;
for(i=1;i<=num;i++)printf("%d\n",i);
/*
*
如上所述，上句展开为：for(i=1;i<=2*2+1+1;i++)printf("%d\n",i);
*
所以：循环将执行6次
*/
}
/*
切记注意：每一个宏百进行替换时只是替换“正文”中的内容，而不包括预编译语句的内容，
否则就会像不少人理解的那样，错误地认为第2个题中的循环将执行7次
*/

㈩ C语言中，宏替换的替换规则

简单来说：宏定义又称为宏代换、宏替换，简称“宏”。宏替换是C/C++的预处理中的一部分,在C++标准中有4条规则来定义替换。

规则1：实参替换。

本条规则描述带参数的宏的替换过程。

对于宏定义中的形参,在替换列表中,如果不是作为#或##的操作数,那么将对应实参完全

展开(相当于对实参进行求值),然后将替换列表中的形参替换掉.如果是#或##的操作数，

那么不进行替换。

规则2：多次扫描。

在所有的形参替换为实参后,对结果进行再次扫描,如果发现还有可替换的宏,则进行替换，

否则中止。

规则3：递归替换抑制。

如果在替换列表中发现当前正在展开的宏的名字，那么这里不进行替换.更进一步,在嵌套

的替换过程中发现已经替换过的宏的名字,则不进行替换。

规则4：递归预处理抑制。

如果替换后的结果形成预处理指令，则不执行这条预处理指令。

看几个C++标准中的例子：

#define x 3

#define f(a) f(x * (a))

#undef x

#define x 2

#define g f

#define z z[0]

#define h g(~

#define m(a) a(w)

#define w 0,1

#define t(a) a

f(y+1) + f(f(z)) % t(t(g)(0) + t)(1)；

g(x+(3,4)-w) | h 5) & m(f)^m(m)；

其结果分别是

f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1)；

f(2 * (2+(3,4)-0,1)) | f(2 * ( ~ 5)) & f(2 * (0,1))^m(0,1)；

对于第一个,主要在于t(t(g)(0) + t)(1)的展开。

容易计算出最外层的t的实参是f(2 * (0)) + t，而作为t的参数传入时其中的t是

正在被展开的宏,所以根据规则3,不对这个t进行处理,保持不变,得到f(2 * (0)) + t(1)。

对于第二个，h 5)被替换为g(~5)，应用规则2，被替换为f(2 * ( ~ 5))。

而m(m)首先被替换为m(w)，然后应用规则2再次进行替换，但是m已经是替换过的了，所以保持

不变,只对w进行替换。

#define str(s) # s

#define xstr(s) str(s)

#define debug(s, t) printf("x" # s "= %d, x" # t "= %s",

x ## s, x ## t)

#define INCFILE(n) vers ## n /* from previous #include example */

#define glue(a, b) a ## b

#define xglue(a, b) glue(a, b)

#define HIGHLOW "hello"

#define LOW LOW ", world"

debug(1, 2);

fputs(str(strncmp("abcd", "abc", ’4’) /* this goes away */

== 0) str(: @ ), s);

#include xstr(INCFILE(2).h)

glue(HIGH, LOW);

xglue(HIGH, LOW)

其结果分别是

printf("x" "1" "= %d, x" "2" "= %s", x1, x2);

fputs("strncmp("abc\0d", "abc", ’\4’) = = 0" ": @ ", s);

#include "vers2.h"

"hello";

"hello" ", world"

关键是glue和xglue.

对于glue(HIGH, LOW)，首先有一个规则1的抑制,得到HIGHLOW;的结果,然后二次扫描,得到

"hello"；

对于xglue(HIGH, LOW)没有抑制效果,所以对参数求值,分别得到HIGH和LOW ", world",即

glue(HIGH, LOW ", world")。

然后进行连接操作得到HIGHLOW ", world",最后再扫描一次得到"hello" ", world"

如果考虑字符串的自然的连接,就可以得到"hello, world"了。

(10)宏替换是在程序编译时进行扩展阅读

宏语言是一类编程语言，其全部或多数计算是由扩展宏完成的。宏语言并未在通用编程中广泛使用，但在文本处理程序中应用普遍。例如， C preprocessor C预处理器Internet Macros(iOpus) M4(如前所述，源于AT&T，捆绑于Unix)

宏定义

c程序提供的预处理功能之一。包括带参数的宏定义和不带参数的宏定义。具体是指用一个指定的标志符来进行简单的字符串替换或者进行阐述替换。形式为：

#define标志符[（参数表）] 字符串

宏名

在上定义中的标志符被称为“宏名”。

宏展开

在c程序编译时将宏名替换成字符串的过程称为“宏展开”。

宏语言是一类编程语言，其全部或多数计算是由扩展宏完成的。宏语言并未在通用编程中广泛使用， 但在文本处理程序中应用普遍。例如，

C preprocessorC 预处理器

Internet Macros(iOpus)

M4(如前所述，源于AT&T，捆绑于Unix)