怎么让宏定义在编译时计算

⑴ 在C语言中如何用标准宏定义实现计算两个参数中的最小值

你可以用这三个眼睛操作符(?:)实现，定义，#定义最小(x,y) ((x)<(y)?(x) (y))，测试代码如下:

//程序功能实现，计算两个数字的最小值。

包括< stdio, h >。

定义最小(x, y) ((x) (y)?(x):(y))

Int main(Int argc, char *argv[])

{Int x = 10, y = 15;

Printf(" MIN(% d % d)= % d n”,x,y,MIN(x,y));

返回0;}

需要注意的是，宏定义是原始的替换，您需要确保替换的准确性，例如，

定义最小(x, y) (x < y?X:y)，在这个定义之后，宏表达式可能看起来是一个问题，而不是期望的结果，例如下面的例子，它可以区分出不同，而编译器可能有不同的结果。

包括< stdio, h >。

定义MIN1 (x, y) (x < y?X,y)

定义MIN2 (x, y) ((x) (y)?(x):(y))

Int main(Int argc, char *argv[])

{Int x = 10, y = 15;

Printf(" MIN1(% d % d)= % d n ",x,y,MIN1(+ = 2 x,y));/ /输出MIN1 = 24 (24 (9)

X = 10;

Printf(" MIN2(% d % d)= % d n ",x,y,MIN2(+ = 2 x,y));/ /输出MIN2 = 14 (14,15)

返回0;

⑵ lisp的宏怎么在编译时展开

Scheme 的 syntax-rules 确实会展开成 (let ((a 12)) (* a x))：
(define-syntax test
(syntax-rules ()
[(_ x) (let ([a 12]) (* a x))]))

clisp、clojure 和 scheme 的 syntax-case 则允许更显式地标注哪些部分给展开成结果，也就是说，下面的 clisp 宏定义：
(defmacro test (x) (let ((a 12)) `(* ,a ,x)))

展开的结果是 (* 12 x) 。

⑶ C++ 中define（宏定义） 各种用法（含特殊），小举个例子，谢谢！

1、define是宏定义，程序在预处理阶段将用define定义的内容进行了替换。因此在程序运行时，常量表中并没有用define定义的常量，系统不为它分配内存。而const定义的常量，在程序运行时，存在常量表中，且系统为它分配内存。

2、define定义的常量，预处理时只是直接进行了替换，因此在编译时不能进行数据类型检验。而const定义的常量，在编译时进行严格的类型检验，可以避免出错。

3、define定义表达式时要注意“边缘效应”。

例如：

#defineN1+2；

floata=N/2.0;

按照常规做法，可能会认为结果是3/2=1.5；

但是实际上，结果应该为1+2/2.0=2.0；

若想要实现3/2，则#defineN(1+2)；

即为避免边缘效应，一定要加括号。

(3)怎么让宏定义在编译时计算扩展阅读

C++宏定义

#define命令是C++语言中的一个宏定义命令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。

1、简单的宏定义：

#define <宏名> <字符串>

例： #define PI 3.1415926

2、带参数的宏定义

#define <宏名> (<参数表>) <宏体>

例： #define A(x) x

⑷ C语言宏定义计算问题

答案是21
因为你定义的f(x) x*x ,而你下面的i=f(4+4)/(2+2)中是讲4+4作为x的值，所以展开的时候是这样的， i=4+4*4+4 /（2+2），所以结果是 i=4+16+1 ，当然是21了

⑸ C语言宏定义 用条件编译

条件编译以及所有前面带“#”的语句，是在编译阶段执行的语句，不会生成运行时的代码。而你的y是在运行时才进行赋值的，所以是无法用条件编译来实现的。
直接写成条件语句就行：
{
if R
printf("%d是闰年\n",y);
else
printf("%d不是闰年\n",y);
}

⑹ C语言宏定义

楼主看看书，仔细看看编译预处理都做了哪些事情。

程序设计语言的预处理的概念：在编译之前进行的处理。 C语言的预处理主要有三个方面的内容： 1.宏定义； 2.文件包含； 3.条件编译。 预处理命令以符号“#”开头。

宏定义又称为宏代换、宏替换，简称“宏”。预处理制作单纯的宏展开，并不是检查语法错误，所说义是错误的。

语法错误都是编译阶段才检查的。预处理是不检查的。

⑺ C语言宏定义算法

宏只是在编译的时候进行替换，而不会对定义的内容进行计算，只是单纯的替换， 首先N 定义为2，M 定义为N+1, 在编译的时候，C系统就会把这里的N变为2，
下面的NUM定义为了2*M+1,在编译的时候，就直接把M变为N+1，放进去， 系统只是做了替换，
如果你用 #define N 2
#deine M (N+1)
#deine MUN 2*M+1 则可以得到MUN为2*（N+1)+1，要记住，宏只是替换，

⑻ 宏定义怎么计算

宏定义一种抽象（Abstraction），它根据一系列预定义的规则替换一定的文本模式。
注意动词“替换”，因此宏定义是不会真正“计算”任何东西，仅仅是“替换”而已。
例如：
#define MULTIPLY(x, y) x * y
这个宏定义不会计算 x 乘以 y这个表达式，而仅仅在编译过程把MULTIPLY(x, y)形式的表达式替换成 x * y
而实际代码中：MULTIPLY(1+2, 3)
替换后 1+2 * 3， 和预计计算 (1+2) * 3 完全不同。

⑼ C语言中的宏定义如何使用

宏定义又称为宏代换、宏替换，简称"宏"。
格式:
#define 标识符 字符串
其中的标识符就是所谓的符号常量，也称为"宏名"。
预处理(预编译)工作也叫做宏展开:将宏名替换为字符串。
掌握"宏"概念的关键是"换"。一切以换为前提、做任何事情之前先要换，准确理解之前就要"换"。
即在对相关命令或语句的含义和功能作具体分析之前就要换:
例:
#define Pi 3.1415926
把程序中出现的Pi全部换成3.1415926

⑽ 在C语言中如何用标准宏定义实现计算两个参数中的最小值

可以通过三目运算符（? :）实现，这样定义，#define MIN(x,y) ((x)<(y)?(x):(y))，测试代码如下，
//程序功能实现，计算两个数的最小值
#include <stdio.h>
#define MIN(x,y) ((x)<(y)?(x):(y))
int main(int argc, char *argv[])
{
int x=10,y=15;
printf("MIN(%d,%d)=%d\n",x,y,MIN(x,y));
return 0;
}

需要注意的是，宏定义是原样替换，需要保证替换后的准确性，例如，
#define MIN(x,y) (x<y?x:y)，这样定义后，宏表达式则可能出现问题，不是想要的结果，比如下面的例子，可以看出区别，编译器不同结果可能不同。
#include <stdio.h>
#define MIN1(x,y) (x<y?x:y)
#define MIN2(x,y) ((x)<(y)?(x):(y))
int main(int argc, char *argv[])
{
int x=10,y=15;
printf("MIN1(%d,%d)=%d\n",x,y,MIN1(x+=2,y));//输出MIN1(24,15)=24
x=10;
printf("MIN2(%d,%d)=%d\n",x,y,MIN2(x+=2,y));//输出MIN2(14,15)=14
return 0;
}