#define LED1 1 //P01 #define EN_LED1() {GP0CON &=~(uint32)(0

定义一个名为GPIO_Pin_0的符号,该符号等价于((u16)0x0001),也就是一个无符号短整型的0x0001.
例如当对寄存器写入GPIO_Pin_0时,即相当于将该寄存器的最低位置位、其余15位清零.

宏定义错误!更正：
#define OUT(x) F(int x) {return(P*x*x);}其中,OUT(x)相当于函数F(int x)的别名.所以在语句：
printf("%d\n",OUT(x))中OUT(x)相当于调用函数

#define ADC_CHSEL_RES(n,m) _SBF(4*n,m)
表示当你在程序中调用ADC_CHSEL_RES时,实际调用_SBF函数,调用时和函数调用相似,如ADC_CHSEL_RES（1,2）;
#define ADC_INT_ENABLE _BIT(0) 是表示ADC_INT_ENABLE _BIT的值为0,当你在程序中使用到ADC_INT_ENABLE _BIT则表示值为0,可将其作为常量使用.

#define a 8通俗点理解就是a等价于8,#define b 8这个就是b等价于 8.每当运算里有a和b时,就会自动用8和 8来替换a和b.

#define P(x) x/x
#define P(10) == 10/10 == 1
#define P(4+6) == 4+6/4+6 == 4+1+6 == 11

#define 是C/C++中的宏定义标识符,#define A B 的意思就是在编译过程中,用B字符串来替换代码中所有存在A的地方.
这句代码的写法不正确,正确的代码应该类似于 #define A "abcd",而不是#define A B abcd.

你 的 “return a[a+1];”这里有错误.貌似去掉那一行也行.
你定义了容量为20的整形数组 a[20],初始化时后10个元素值为0,前10个元素值依次为1-10
你调用了fun(int a[],int n,int m)函数,传入参数a的地址,2和9
在fun函数里面
当m大于n时数组元素向右移动位置.
然后m自减,重新测试移位条件..也就是上一步操作了
所以根据传入的参数可以知道
把数组a从下标为9开始向右移位,一直到下标为1停止移位.
fun()函数结束
得到的移动过某些元素位置的数组a
a[0]=1,
a[1]=2,
a[2]=3,
a[3]=3,
a[4]=4,
a[5]=5,
a[6]=6,
a[7]=7,
a[8]=8,
a[9]=9,
a[10]=10,
a[11]=0,
a[12]=0,
...
a[19]=0,

C语言中的宏在替换时,是直接用实际参数代替形式参数,不能人为加括号.所以f(4+4)/(2+2)是4+4*4+4/(2+2)=21

fun(1,2,3)1*3+2
结果为 5fun(fun(2,3,4),5,6)2*4+3*6+5
结果为 31

选择B
因为#define MOD(x,y) x%y是在运行时直接代入计算.
所以实际上计算的结果是MOD(b,a+4),即printf(″%dn″,b%a+4)；
b%a=3,所结果是3+4=7

#define ABC(x) x*x
在你使用ABC(x)的时候,计算机自动的,进行原样的替换
b=ABC(a+1); 就被替换为b=a+1^a+1
注意是原样替换,所以不是(a+1)^(a+1)
所以答案是D

i=f(4+4)/(2+2);
这里要注意，在编译的时候，编译成目标文件时实际是这样的：
i=f(8)/4;
也因为这个特点，在定义宏的时候可以这样写：
#define _K 1024
#define _M (1024*_K)
#define _G (1024*_M)
这样写，不会让处理器多做乘法运算，而是编译器帮忙干完了这个活

楼主,你要注意,prt(a,b) 是“宏”,不是函数.
　　因此,原始代码看起来很迷惑人的!因为在编译前,是要进行宏替换的,因此,我们先看看宏替换之后的代码：（为减少内容,只看if语句那儿）
//完成宏替换后的代码：
if(x>y) if(!x) y=x;
else if(!y) x=y;

//这样仍然有点“迷惑人”
//那再给它加上花括号,流程就清晰了：
if(x>y) {
if(!x) y=x;
else {if(!y) x=y;}
}
//看上面的代码,运行结果很明晰了吧! 因最初x=1 ,而y=0因此,第一个if(x>y)为真,　　然后if(!x) 为假,执行了 else语句块.　　在else的语句块中,if(!y) 为真,就执行了x = y最终结果,就是x和y的值都为 0 了.

用 (c==c==c) 来代替T（t）

选B.
这样做的.结果是这样出来的.5+3*5+3 = 23.
因为宏定义只是简单的替换的.直接替换掉X的值得.所以得出来的结果就是上面的那样的结果的.

定义了带参数的宏max(a,b) .
只要文本中出现max(a,b)格式的文本,无论a b为何种类型,
均替换为(((a)>(b))?(a):(b))格式的文本, 再进行编译

选答案②,宏展开的结果是(10+10)*5,这是符合TWO*5的原意的,答案①展开的结果是10+10*5,不符合原意.

0x7000 16进制数 表示一个地址
括号把 volatile unsigned int *包含起来,表示里面是一个整体
volatile unsigned int *
unsigned int * 无符号整数指针
volatile 告诉编译器 这个变量是变化的,每次取值一定要从这个地址取,不能优化取值的代码.有时候编译器计算时,对于一个变量会把它的值放在寄存器里,而不去地址读,因为编译器认为没有其他的线程会修改这个变量,就不去读了

因为编译时遇到宏只是展开,在没有加括号的情况下,3*M*3 展开为 3*3+2*3,所以是15.
一般定义宏都强调注意这点,要加括号
#define M (3+2)
这样就能得到45了.

如果a==b,这个表达式的值就为1,否则为0.为1的话就相当于#define _match(a,b) 1

你的glutSolidSphere中的第一个参数太大,要小于1才能看到

d=SUB(A+B)*C //a=a+b
d=(a+b)-(a+b)*c //没有括号把前面括起来,因为这是define定义的宏的特点
d=5-5*5=-20

（c+b）-(c+b)×d

#define st(x) do { x } while (__LINE__ == -1)
1, __LINE__ 是个宏,它代表当前代码在源文件的行号,它是大于0的,所以__LINE__ == -1 等同于0,化简为：
#define st(x) do { x } while (0)
2,do {} while (0)通常用于宏中, 为的是避免如下情况：
#define st(x) x
那么我们在调用 if (0) st(a = b; b = c;) 时会被解释成
if(0)
a = b;
b = c;
可见 if 只对a = b；起作用.
看明白了吗? 不明白的话继续问

f(2+2)/f(1+1)
=2+2*2+2/1+1*1+1
=2+4+2+1+1
=10

C语言的宏机制就是按位置替换，不加其它修饰
那么x的位置替换成a
y的位置替换成x+5
z的位置替换成y-3.1
最后就出来了一个和本意不同的式子
a=x+5*y-3.1;
这里还要注意定义宏的时候不需要分号
所以x=y*z;后面那个分号也是宏的
C没有那个分号，所以错啦~

输出：5,25
思路：f(3,2,1)=3*1+2=5
f(6,5,f(3,2,1))=6*3*1+2+5=25

unsignedcharzeroArea_3[4];printf("pleaseinputtwostringsn");对比if(line==10)#defineLEFT260

比如REC ( 1+2,2+3)前者展开后是 (1+2*2+3),这个应该不是想要的结果,而后者展开后是
（（1+2）*（2+3））这就是想要的结果.

举个例子吧,如果说你在做一个项目,这个项目的代码很长,有5000多行,而且基本上裏面的同一个常量N就占了3000多行,如果说今后你要是想对这个常量N的值进行修改,如果在程序的开始没有定义一个＃define N,那么改起来不是很麻烦,3000多行啊,那不是要晕过去了～如果你事先定义了一个＃define N ‘常量值’,那么当你要修改程序内部的常量值时,只要修改N后面的常量值就等于把程序内部的要修改的相同常量值都改了,那就很方便了.在程序执行期间其值可以改变的量称为变量,变量类型又分为系统变量和用户自定义变量,用户自定义变量其实和系统变量含义是一样的,在学到结构化编程的时候,你就会明白自定义变量的意思了.系统变量分为四种,int整形变量,用户存放整数的变量,占4个字节的大小；float单精度浮点型,就是存放小数点的数值,占4个字节大小；double高精度浮点型,相对float而言,double保畱的小数点位数更精确,占8个字节的大小；char字符变量,主要存放字母,占1个字节的大小eg:“#define n 10”C语言中这一句表示什么?表示n=10,在以下的程序中你可用n来表示数字10.这是一个宏定义,表示凡是在程序中出现的n变量,都被赋于值10.再纠正一下,在宏定义中,一般用大写.准确来说“#define n 10”不是n=10的意思,
而是用10替换掉n,这是有区别的.
例如：#include
#define N a+b
void main(){int a=1,b=2;
printf ("%d",N*5);}输出的是11,而不是15.又例如：
#include
#define N (a+b)

宏 要加括号 不然有风险
变量 要初始化
c是区分大小写的

直接代入即可，N(2, 2 + 5) = M(2) + M(2 + 5) = 2 * 2 + 2 + 5 * 2 + 5 = 21
这道题主要是考的宏调处时，编译器是怎么处理的。
编译器在这里只做简单的替换，不会给你自动加括号。
所以一般在用宏定义时，最好加上括号，才能得到想要的结果。
这这道题改成如下形式，
#define M（x） （x*x）
#define N（x，y） （M（x）+M（y））
便是写宏定义的规范形式。

#define宏是直接替换,不会先给你计算的
add(a+b) = a+b*a+b
d = add(a+b)*c = a+b*a+b*c =4+4*6+6*7 = 4+24+42 = 70
都是直接替换,不要自己加一些没有的字符.

#define N 3 #define Y(n) ((N=1)*n) 则表达式2*（N+Y（5+1))的值是
先进行宏替换
2*（N+Y（5+1))=2*（N+ ((N=1)*5+1) )
这里先做N=1
所以结果是2*（1+ (1*5+1) )=14

定义一个宏,x是参数
x.val >> 1 逻辑右移一位 然后‘与’上0x3f

选择D
因为F（M,N）是M*N
F(x+y,x-y);就是x+y*x-y 5+3*5-3=17
F(x-y,x+y);就是x-y*x+y 5-3*5+3=-7
若是加上括号a1=F((x+y）,（x-y）)
a2=F((x-y),(x+y));那这道题就选A

1 宏只是简单的替换,所以M(a+b,b+c,c+a)展开后就是：a+b*b+c+c+a = 12
2 a是这个数组的首指针,指向数组第一个元素,也就是9,a+5指向数组第6个元素,也就是4.

宏不难理解啊,VPORT和VAR作用是一样的,都是生成一个条目,这个条目的字段分别是：
{ 字段名称,一个对应的CONFIG_TYPE ,字段在结构体 or_state_t 中的偏移位置,initvalue }
至于这个条目的作用或者意义,那就要看具体是怎么使用的了.

status ListInsert_Sq(SqList &L,int i,ElemType e)
{
//在顺序线性表L中第i个位置之前插入新的元素e,
//i的合法值为1=q;p--) /*~大写p改成小写~*/
*(p+1)=*p;//插入位置及以后的元素右移
*q=e;//插入e
++L.length;//表长增1
return OK;
}//ListInsert_sq

你好,这个考验视力,很不幸,A,B确实一样除了减号小一点,
所以我觉得A,B都是正确的,
希望回答能帮到你,哪里不清楚再问.

define定义一个宏,在编译时会进行简单的替换,即将3+2替换成N,为3+2*2=7；如果想让答案为10的话,可以这样定义#define N （3+2）,希望可以帮到你!

意思是用
IS_GPIO_ALL_PERIPH(PERIPH)
代替
(((PERIPH) == GPIOA) || ((PERIPH) == GPIOB) ||((PERIPH) == GPIOC) || ((PERIPH) == GPIOD) || ((PERIPH) == GPIOE) || ((PERIPH) == GPIOF) || ((PERIPH) == GPIOG))
到程序中去.
而#define 后的内容要求只能写在同一行上,如果内容过多写不开,可以用 空格 来连接下一行的内容.这种写法只是编程习惯,使程序看上去清晰明了.
#define 的作用
　　在C或C++语言源程序中允许用一个标识符来表示一个字符串,称为“宏”.被定义为“宏”的标识符称为“宏名”.在编译预处理时,对程序中所有出现的“宏名”,都用宏定义中的字符串去代换,这称为“宏代换”或“宏展开”.宏定义是由源程序中的宏定义命令完成的.宏代换是由预处理程序自动完成的. 在C或C++语言中,“宏”分为有参数和无参数两种.
宏定义的优点
(1) 方便程序的修改
使用简单宏定义可用宏代替一个在程序中经常使用的常量,这样在将该常量改变时,不用对整个程序进行修改,只修改宏定义的字符串即可,而且当常量比较长时, 我们可以用较短的有意义的标识符来写程序,这样更方便一些.我们所说的常量改变不是在程序运行期间改变,而是在编程期间的修改,举一个大家比较熟悉的例 子,圆周率π是在数学上常用的一个值,有时我们会用3.14来表示,有时也会用3.1415926等,这要看计算所需要的精度,如果我们编制的一个程序中 要多次使用它,那么需要确定一个数值,在本次运行中不改变,但也许后来发现程序所表现的精度有变化,需要改变它的值, 这就需要修改程序中所有的相关数值,这会给我们带来一定的不便,但如果使用宏定义,使用一个标识符来代替,则在修改时只修改宏定义即可,还可以减少输入 3.1415926这样长的数值多次的情况,我们可以如此定义 #define pi 3.1415926,既减少了输入又便于修改,何乐而不为呢?
(2) 提高程序的运行效率
使用带参数的宏定义可完成函数调用的功能,又能减少系统开 销,提高运行效率.正如C语言中所讲,函数的使用可以使程序更加模块化,便于组织,而且可重复利用,但在发生函数调用时,需要保留调用函数的现场,以便子 函数执行结束后能返回继续执行,同样在子函数执行完后要恢复调用函数的现场,这都需要一定的时间,如果子函数执行的操作比较多,这种转换时间开销可以忽 略,但如果子函数完成的功能比较少,甚至于只完成一点操作,如一个乘法语句的操作,则这部分转换开销就相对较大了,但使用带参数的宏定义就不会出现这个问 题,因为它是在预处理阶段即进行了宏展开,在执行时不需要转换,即在当地执行.宏定义可完成简单的操作,但复杂的操作还是要由函数调用来完成,而且宏定义 所占用的目标代码空间相对较大.所以在使用时要依据具体情况来决定是否使用宏定义.
在#define中,标准只定义了#和##两种操作.#用来把参数转换成字符串,##则用来连接两个前后两个参数,把它们变成一个字符串.
程序举例
#include 　　
#define paster( n ) printf( "token " #n" = %dn ", token##n ) 　
void main() 　　
{ 　　
int token9=10; 　　
paster(9); 　　
} 　　
输出为 token 9 = 10

#include
//a[N] 1,2,3,4,5,6,7,8,9,10,0,0,0..
//从a[0+1]开始移动后：1,2,2,3,4,5,6,7,8,9,10,0,0..
//输出前五个：1,2,2,3,4
#define N 20
fun(int a[],int n,int m)//a[]元素后移,从a[n+1]到a[m]
{
int i;
for(i=m;i>n;i--)
a[i+1]=a[i];
return m;
}
void main()
{
int i,a[N]={1,2,3,4,5,6,7,8,9,10};
fun(a,0,N/2);
for(i=0;i

#define 是宏定义，宏定义属于语句的，printf是函数，不是语句。d那段代码就相当于int i;while(i<5){i++;}i++;答案肯定是6.

输出12
宏不是函数,只是逐字替换,它会把M(a+b,b+c,c+a)变成1+2*2+3+3+1,就是12了

2*6+2*（（N+1）*N+1）=2*6+2*31=74
注意不是2*6+2*（（N+1）*（N+1））!

宏展开后为 (4*4)/(2+2*2+2)

#define A B
A宏名,B宏内容
编译预处理中,程序中,所有A的宏,将用B的定义替换.
如
#define PI 3.14
程序中所有出现PI的地方,将用浮点型常量,3.14代替.
0*0x100u结果是0.u表示无符号常量.加括号,可以提高在实际程序中的运算优先级.
如初始化ADC12的程序：
ADC12CTL1 = SHS_1 + SHP + CONSEQ_2; // TA trig., rpt conv.
ADC12MCTL0 = SREF_1 + INCH_10; // Channel A10, Vref+
ADC12IE = 0x01; // Enable ADC12IFG.0
ADC12CTL0 = SHT0_8 + REF2_5V + REFON + ADC12ON + ENC; // Config ADC12
再理解上一段程序,就懂了.后面的内容是配置的参数,程序编译后,实际上这些内容都是常量.
这种做法主要目的是增强程序的可读性.