c++十六进制加法_C++十六进制宏的用法

流行的用法：用二进制的每一位代表一种状态。

001,010,100这样就表示三种状态。

通过或|运算就可以组合各种状态。

001 | 010 = 011

001 | 010 | 100 = 111

通过与&运算可以去除某种状态。

111 & 001 = 110

可以定义这样的宏组合成函数的参数

#define P1 0x001L // 001

#define P2 0x002L // 010

#define P3 0x004L // 100

void Func(long){}

Func(P1 | P2);

可以这样判断某位是否是1

由于001与xxx只有两种状态000或001

比如001&100=000,001&101=001

void Func(long l){

if(l&P1){} // 001与xx0 = 000,001与xx1 = 001

if(l&P2){} //

}

下面我用调料为例写段代码直观说明：

#include 

#include 

using namespace std;

#define TL_YAN       0x001L //00001 盐

#define TL_TANG      0x002L //00010 糖

#define TL_JIANGYOU  0x004L //00100 酱油

#define TL_CU        0x008L //01000 醋

#define TL_LAJIAO    0x010L //10000 辣椒

typedef long LONG;

//调料void TiaoLiao(LONG l)

{

if (l&TL_YAN)//00001 & xxxx1 = 00001    {

cout<

}

if (l&TL_TANG)//00010 & xxx0x = 00000    {

cout<

}

if (l&TL_JIANGYOU)

{

cout<

}

if (l&TL_CU)

{

cout<

}

if (l&TL_LAJIAO)

{

cout<

}

}

void main()

{

cout<

TiaoLiao(TL_LAJIAO | TL_TANG);

system("pause");

}

这样做的好处是代码比较优雅，你也可以用枚举，

但是想实现这样灵活的组合好像没这么容易。

十六进制表示二进制，比较容易判断某位的值。

参考：

C++中如何表示2进制，8进制、16进制变量

1、C和C++都没有提供二进制数的表达方法。

2、C,C++语言中，如何表达一个八进制数呢？

如果这个数是 876,我们可以断定它不是八进制数，因为八进制数中不可能出7以上的阿拉伯数字。但如果这个数是123、是567，或12345670，那么它是八进制数还是10进制数，都有可能。

所以,C,C++规定，一个数如果要指明它采用八进制，必须在它前面加上一个0，如：123是十进制，但0123则表示采用八进制。

int 0123;

这就是八进制数在C、C++中的表达方法。但是有一个例外就是转意符'\'。

因为C,C++规定不允许使用斜杠加10进制数来表示字符,所以：

'?' //ASCII值是63

'\077' //是8进制表示'?'，0可以省略，因为C,C++规定不允许使用斜杠加10进制数来表示字符

'\0x3F' //是16进制表示'?'

3、 C，C++规定，16进制数必须以 0x开头

int 0x15A

其中的x也也不区分大小写。(注意：0x中的0是数字0，而不是字母o)。

注：

1) 8进制和16进制只能用达无符号的正整数，如果你在代码中里：-078，或者写：-0xF2,C,C++并不把它当成一个负数。

2) Qt中把十进制整型值转换成16进制 的字符串方法。

int a = 63;

QString s = QString::number(a, 16);                   // s == "3f"

QString t = QString::number(a, 16).toUpper();     // t == "3F"

3) QString 存储16进制值

//将字符串以16进制形式输出

QString cmd = 0x0a;

qDebug() <

4)QString 按照字符串表面格式 转换成16进制

QString str = "FF";

bool ok;

int hex = str.toInt(&ok, 16);       // hex == 255, ok == true 0xFF

int dec = str.toInt(&ok, 10);       // dec == 0, ok == false

4) QByteArray 存储16进制值

static const char mydata[] = {

0x00, 0x00, 0x03, 0x84, 0x78, 0x9c, 0x3b, 0x76,

0xec, 0x18, 0xc3, 0x31, 0x0a, 0xf1, 0xcc, 0x99,

0x6d, 0x5b

};

QByteArray bd = QByteArray::fromRawData(mydata, sizeof(mydata));

qDebug() <

qDebug() <

5) QChar 存储16进制值，打印

QChar c = 0x0A;

QByteArray array;

array.append(c);

qDebug() <

6)char* 存储16进制，打印

char c[] = {0x0A,0x0B,'\0'};

QByteArray array(c);

qDebug() <

1、将十六进制字符串转化为十进制整数

WORD DEC( CString str )

{

WORD decvalue=0;

int i=0;

for( i=0 ; i

{

if(str[i]>= 'a'&&str[i]<='f')

{

decvalue*=16;

decvalue+=str[i]-'f'+15;

}

else if ((str[i]>='A') && (str[i]<='F')) {

decvalue*=16;

decvalue+=str[i]-'F'+15;

}

else if(str[i]>='0'&&str[i]<='9')

{

decvalue*=16;

decvalue+=str[i] - '0';

}

}

return decvalue;

}

2、将二进制字符串转化为十进制整数

WORD BINToDEM( CString str )

{

WORD decvalue=0;

int i=0;

for( i=0 ; i

{

if(str[i] == '1')

{

decvalue += WORD(pow(2, (str.GetLength() - 1 - i) ));

}

}

return decvalue;

}

3、将十进制整数转化为二进制字符串

CString DECToBIN( int idata )

{

CString tempStr, outStr;

int iBIN[32];//存储每bit二进制的数组

int i = 0;

while (idata)

{

iBIN[i] = idata%2;

idata = idata/2;

i++;

}

for (int j = i-1; j >= 0; j--)

{

tempStr.Format(L"%d", iBIN[j]);

outStr = outStr + tempStr;

}

return outStr;

}

C++位运算详解

位运算是对表示数据的基本单元进行"加和","减除"的方法.

首先一个位(bit)单位就是0或1,硬件表示就是一个肪冲的开和,这是硬软通迅最基本的单元.我们所说的一个字节(byte)需要8个位来表示,一个字(WORD)要两个字节,16个位表示.一个双字(DWORD)要两个字,四个字节,32个位来表示.

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    -----------------------------|

在C++中往往需要用字节,字,双字来操作数据,然而使用这种二进数来显示数并不是很方便,而使用十进制数显示,不能化整,因此选择使用16进制数来显示数据,因为一个16进制数每个个位正好就是4个二进制位的表示,一个字节8位,一个16进制数4位表示,因此一个字节用两个16进制数表示.据此，实际图像运算时双字指针比单字指针快，单字指针比字节指针快

8B+字符的ascII对照:

8                   B                    +

十进制:   56                 66                 43

16进制:  38                 42                 2B

二进制:   0011 1000    0100 0010    0010 1011

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

位运算有六种运算符可以使用:

&       与运算

|       或运算

^       异或运算

~       非运算(求补)

>>       右移运算

<<       左移运算

与运算(&)

双目运算。二个位都置位(等于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

异或运算(^)  双目运算。二个位不相等时，结果为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;