1、优先级问题

 1) 传入变量优先级

   #define MULTI(a,b) a * b

   MULTI(1+2,3)   => 1 + 2 * 3 其实是想要(1 + 2) * 3

 2) 作为值返回时,类似1)

   #define ADD(a,b) (a) + (b)

   int c = ADD(a,b) * 3; => (a) + (b) * 3  其实是想要(a + b) * 3

 所以,一般的规则是:宏里面参数全部用括号括起来;如果作为值返回,整个表达式也用括号括起来。

 所以,上面最好这么写:

   #define MULTI(a,b) ((a) * (b))

   #define ADD(a,b)  ((a) + (b))

2、实际使用参数和宏内部变量同名

   #define HASH(str,sz,rst) do{unsigned int n = 0; n = xxx; rst = n % sz;}while(0)

 这是一个hash的宏实现,其中定义了一个临时变量n,根据str计算n,然后对sz求模并把返回值赋给传进来的rst.

 这么调用:

   int n;

   HASH("hello",7,n);

 不会达到改变n的效果,因为实际使用参数n和宏内部的变量n同名。宏扩展中最后一条语句是:n = n % sz;因为宏内部n有更小作 用域,实际赋值的是宏内部的那个临时变量n。外面调用的n不会有任何改变。

 这个副作用有些隐蔽,一般的规则是:宏内部变量使用一种不同风格的命名方式。

 比如:

   #define HASH(str,sz,rst)  do{unsigned int __n = 0; __n = ...

3、++,--

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

   int a = 3,b = 2; 

   int c = MAX(a++,b);

 执行看看,不但a的值不是和想要的一致,返回值c也会让你大吃一惊,哈哈。(a = 5,c = 4)

 在宏内部一个变量"执行"多少次,它就自增或自减了多少次。

 所以一般使用宏最好不要传入自增自减。如果你一定要在宏里消除这个副作用,可以这样:

   #define MAX(a,b)  ({int __x = (a), __y = (b);(__x > __y) ? __x : __y;})

 也就是:保证传入宏的参数在内部只使用一次。(注意:传入a++或++a都能得到各自正确的效果)

 这里的内部变量__x,__y是不需要用括号包起来的,原因可以自己想想。

 另外对宏中括号的使用补充说明两点:

  因为宏中定义了临时变量,所以要用{}括起来;

  因为要返回值,所以外面还要用()括起来({}不返回值);

 另外,这里还有一个问题:实际中a,b不一定是int的,这个宏中的临时变量声明为int,不通用。

 改进:

   #define MAX(a,b,type) ({type __x = (a), __y = (b);(__x > __y) ? __x : __y;})

 使用:

   MAX(1,2,int);  MAX(1.1,1.2,double);

 是不是感觉怪怪的,有点c++的感觉~~ 这样的使用太复杂了,而且也会给代码的阅读带来难度。

 我觉得好的态度是多了解些宏的可能的副作用,在实际编码中遵守第1、2条规则,不要往宏中传入自增自减的东西,就够了。不要把过多的复杂度全扔给宏,"通用"也不能盲目,因为毕竟:yy是没有极限的。

posted @ 2010-03-11 10:48 小火球 阅读(951) | 评论 (0)编辑 收藏

最近想系统的对位运算了解一下,所以在网上转了这个,分享一下。
关键字:c++位运算

什么是位(bit)?

很简单,位(bit)就是单个的0或1,位是我们在计算机上所作一切的基础。计算机上的所有数据都是用位来存储的。一个字节(BYTE)由八个位组成,一个字(WORD)是二个字节或十六位,一个双字(DWORD)是二个字(WORDS)或三十二位。如下所示:

0 1 0 0 0 1 1 1 1 0 0 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 1 1 1 0 0 0
| | | | | | |
| +- bit 31 | | | bit 0 -+ |
| | | | |
+-- BYTE 3 ---- -+---- BYTE 2 ---+---- BYTE 1 ---+--- BYTE 0 -----+
| | |
+------------ WORD 1 ------------+----------- WORD 0 -------------+
| |
+----------------------------- DWORD -----------------------------+

使用位运算的好处是可以将BYTE, WORD 或 DWORD 作为小数组或结构使用。通过位运算可以检查位的值或赋值,也可以对整组的位进行运算。

16进制数及其与位的关系
用0或1表示的数值就是二进制数,很难理解。因此用到16进制数。

16进制数用4个位表示0 - 15的值,4个位组成一个16进制数。也把4位成为半字节(nibble)。一个BYTE有二个nibble,因此可以用二个16进制数表示一个BYTE。如下所示:

NIBBLE HEX VALUE
====== =========
0000 0
0001 1
0010 2
0011 3
0100 4
0101 5
0110 6
0111 7
1000 8
1001 9
1010 A
1011 B
1100 C
1101 D
1110 E
1111 F

如果用一个字节存放字母"r"(ASCII码114),结果是:
0111 0010 二进制
7 2 16进制

可以表达为:'0x72'

有6种位运算:
& 与运算
| 或运算
^ 异或运算
~ 非运算(求补)
>> 右移运算
<< 左移运算

与运算(&)
双目运算。二个位都置位(等于1)时,结果等于1,其它的结果都等于0。
1 & 1 == 1
1 & 0 == 0
0 & 1 == 0
0 & 0 == 0

与运算的一个用途是检查指定位是否置位(等于1)。例如一个BYTE里有标识位,要检查第4位是否置位,代码如下:

BYTE b = 50;
if ( b & 0x10 )
cout << "Bit four is set" << endl;
else
cout << "Bit four is clear" << endl;

上述代码可表示为:

00110010 - b
& 00010000 - & 0x10
----------------------------
00010000 - result

可以看到第4位是置位了。

或运算( | )
双目运算。二个位只要有一个位置位,结果就等于1。二个位都为0时,结果为0。
1 | 1 == 1
1 | 0 == 1
0 | 1 == 1
0 | 0 == 0

与运算也可以用来检查置位。例如要检查某个值的第3位是否置位:

BYTE b = 50;
BYTE c = b | 0x04;
cout << "c = " << c << endl;

可表达为:

00110010 - b
| 00000100 - | 0x04
----------
00110110 - result

异或运算(^)
双目运算。二个位不相等时,结果为1,否则为0。

1 ^ 1 == 0
1 ^ 0 == 1
0 ^ 1 == 1
0 ^ 0 == 0

异或运算可用于位值翻转。例如将第3位与第4位的值翻转:

BYTE b = 50;
cout << "b = " << b << endl;
b = b ^ 0x18;
cout << "b = " << b << endl;
b = b ^ 0x18;
cout << "b = " << b << endl;

可表达为:

00110010 - b
^ 00011000 - ^0x18
----------
00101010 - result

00101010 - b
^ 00011000 - ^0x18
----------
00110010 - result

非运算(~)
单目运算。位值取反,置0为1,或置1为0。非运算的用途是将指定位清0,其余位置1。非运算与数值大小无关。例如将第1位和第2位清0,其余位置1:

BYTE b = ~0x03;
cout << "b = " << b << endl;
WORD w = ~0x03;
cout << "w = " << w << endl;

可表达为:

00000011 - 0x03
11111100 - ~0x03 b

0000000000000011 - 0x03
1111111111111100 - ~0x03 w

非运算和与运算结合,可以确保将指定为清0。如将第4位清0:

BYTE b = 50;
cout << "b = " << b << endl;
BYTE c = b & ~0x10;
cout << "c = " << c << endl;

可表达为:

00110010 - b
& 11101111 - ~0x10
----------
00100010 - result

移位运算(>> 与 <<)
将位值向一个方向移动指定的位数。右移 >> 算子从高位向低位移动,左移 << 算子从低位向高位移动。往往用位移来对齐位的排列(如MAKEWPARAM, HIWORD, LOWORD 宏的功能)。

BYTE b = 12;
cout << "b = " << b << endl;
BYTE c = b << 2;
cout << "c = " << c << endl;
c = b >> 2;
cout << "c = " << c << endl;

可表达为:
00001100 - b
00110000 - b << 2
00000011 - b >> 2

译注:以上示例都对,但举例用法未必恰当。请阅文末链接的文章,解释得较为清楚。

位域(Bit Field)
位操作中的一件有意义的事是位域。利用位域可以用BYTE, WORD或DWORD来创建最小化的数据结构。例如要保存日期数据,并尽可能减少内存占用,就可以声明这样的结构:

struct date_struct {
BYTE day : 5, // 1 to 31
month : 4, // 1 to 12
year : 14; // 0 to 9999
}date;

在结构中,日期数据占用最低5位,月份占用4位,年占用14位。这样整个日期数据只需占用23位,即3个字节。忽略第24位。如果用整数来表达各个域,整个结构要占用12个字节。

| 0 0 0 0 0 0 0 0 | 0 0 0 0 0 0 0 0 | 0 0 0 0 0 0 0 0 |
| | | |
+------------- year --------------+ month+-- day --+

现在分别看看在这个结构声明中发生了什么

首先看一下位域结构使用的数据类型。这里用的是BYTE。1个BYTE有8个位,编译器将分配1个BYTE的内存。如果结构内的数据超过8位,编译器就再分配1个BYTE,直到满足数据要求。如果用WORD或DWORD作结构的数据类型,编译器就分配一个完整的32位内存给结构。

其次看一下域声明。变量(day, month, year)名跟随一个冒号,冒号后是变量占用的位数。位域之间用逗号分隔,用分号结束。

使用了位域结构,就可以方便地象处理普通结构数据那样处理成员数据。尽管我们无法得到位域的地址,却可以使用结构地址。例如:
date.day = 12;
dateptr = &date;
dateptr->year = 1852;

posted @ 2010-03-10 17:02 小火球 阅读(439) | 评论 (0)编辑 收藏

仅列出标题
共4页: 1 2 3 4 

posts - 28, comments - 3, trackbacks - 0, articles - 0

Copyright © 小火球