预处理命令

#,##

# 和 ## 操作符是和#define宏使用的. 使用# 使在#后的首个参数返回为一个带引号的字符串. 例如, 命令

    #define to_string( s ) # s

将会使编译器把以下命令

    cout << to_string( Hello World! ) << endl;

理解为

    cout << "Hello World!" << endl;

使用##连结##前后的内容. 例如, 命令

    #define concatenate( x, y ) x ## y
...
int xy = 10;
...

将会使编译器把

    cout << concatenate( x, y ) << endl;

解释为

    cout << xy << endl;

理所当然,将会在标准输出处显示'10'.

#line

  #line line_number "filename"
            

#line命令是用于更改__LINE__ 和 __FILE__变量的值. 文件名是可选的. __LINE__ 和 __FILE__ 变量描述被读取的当前文件和行. 命令

    #line 10 "main.cpp"

更改行号为10,当前文件改为"main.cpp".

预定义变量

语法:

__LINE__ __FILE__ __DATE__ __TIME__ _cplusplus __STDC__

下列参数在不同的编译器可能会有所不同, 但是一般是可用的:

• __LINE__ 和 __FILE__ 变量表示正在处理的当前行和当前文件.
• __DATE__ 变量表示当前日期,格式为month/day/year(月/日/年).
• __TIME__ 变量描述当前的时间,格式为hour:minute:second(时:分:秒).
• _cplusplus 变量只在编译一个C++程序时定义.
• __STDC__ 变量在编译一个C程序时定义,编译C++时也有可能定义.

下，找到一个名叫winhex的工具。挺好用的，大家有这样的

问题的时候可以用一下。
猜想一下winhex的恢复指定类型文件工作原理
struct stBitMap
{
 uint fileType;
 uint ver;
 uint size;
 uint createDate; 
}

假如上面是一个位图的文件结构头部分，那么winhex逐步扫

描文件块比较 和这个结构里比较

In an unsigned type, all the bits represent the value. If a type is defined for a particular machine to use 8 bits, then the unsigned version of this type could hold the values 0 through 255.

无符号型中，所有的位都表示数值。如果在某种机器中，定义一种类型使用 8 位表示，那么这种类型的 unsigned 型可以取值 0 到 255。

The C++ standard does not define how signed types are represented at the bit level. Instead, each compiler is free to decide how it will represent signed types. These representations can affect the range of values that a signed type can hold. We are guaranteed that an 8-bit signed type will hold at least the values from 127 through 127; many implementations allow values from 128 through 127.

C++ 标准并未定义 signed 类型如何用位来表示，而是由每个编译器自由决定如何表示 signed 类型。这些表示方式会影响 signed 类型的取值范围。8 位 signed 类型的取值肯定至少是从 -127 到 127，但也有许多实现允许取值从 -128 到 127。

Under the most common strategy for representing signed integral types, we can view one of the bits as a sign bit. Whenever the sign bit is 1, the value is negative; when it is 0, the value is either 0 or a positive number. An 8-bit integral signed type represented using a sign-bit can hold values from 128 through 127.

表示 signed 整型类型最常见的策略是用其中一个位作为符号位。符号位为 1，值就为负数；符号位为 0，值就为 0 或正数。一个 signed 整型取值是从 -128 到 127。

Assignment to Integral Types

整型的赋值

The type of an object determines the values that the object can hold. This fact raises the question of what happens when one tries to assign a value outside the allowable range to an object of a given type. The answer depends on whether the type is signed or unsigned.

对象的类型决定对象的取值。这会引起一个疑问：当我们试着把一个超出其取值范围的值赋给一个指定类型的对象时，结果会怎样呢？答案取决于这种类型是 signed 还是 unsigned 的。

For unsigned types, the compiler must adjust the out-of-range value so that it will fit. The compiler does so by taking the remainder of the value modulo the number of distinct values the unsigned target type can hold. An object that is an 8-bit unsigned char, for example, can hold values from 0 through 255 inclusive. If we assign a value outside this range, the compiler actually assigns the remainder of the value modulo 256. For example, we might attempt to assign the value 336 to an 8-bit signed char. If we try to store 336 in our 8-bit unsigned char, the actual value assigned will be 80, because 80 is equal to 336 modulo 256.

对于 unsigned 类型来说，编译器必须调整越界值使其满足要求。编译器会将该值对 unsigned 类型的可能取值数目求模，然后取所得值。比如 8 位的 unsigned char，其取值范围从 0 到 255（包括 255）。如果赋给超出这个范围的值，那么编译器将会取该值对 256 求模后的值。例如，如果试图将 336 存储到 8 位的 unsigned char 中，则实际赋值为 80，因为 80 是 336 对 256 求模后的值。

For the unsigned types, a negative value is always out of range. An object of unsigned type may never hold a negative value. Some languages make it illegal to assign a negative value to an unsigned type, but C++ does not.

对于 unsigned 类型来说，负数总是超出其取值范围。unsigned 类型的对象可能永远不会保存负数。有些语言中将负数赋给 unsigned 类型是非法的，但在 C++ 中这是合法的。

When assigning an out-of-range value to a signed type, it is up to the compiler to decide what value to assign. In practice, many compilers treat signed types similarly to how they are required to treat unsigned types. That is, they do the assignment as the remainder modulo the size of the type. However, we are not guaranteed that the compiler will do so for the signed types.

当将超过取值范围的值赋给 signed 类型时，由编译器决定实际赋的值。在实际操作中，很多的编译器处理 signed 类型的方式和 unsigned 类型类似。也就是说，赋值时是取该值对该类型取值数目求模后的值。然而我们不能保证编译器都会这样处理 signed 类型。

以上摘自 c++ primer,惭愧，还是再细细的从头品一次这书吧。