预处理命令

#,##

# 和 ## 操作符是和#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++时也有可能定义.

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,惭愧，还是再细细的从头品一次这书吧。

拷贝：

copy（）
reverse_copy()
rotate_copy()
remove_copy()  拷贝不等于某值的元素到另一个序列。
remove_copy_if() 拷贝符合条件的到另一个序列。

填充和生成：
fill()
fill_n() 填充序列中的n个元素。
generate（）为序列中的每个元素调用gen（）函数。

排列：
next_permuttion() 后一个排列。
prev_permutation()

partition() 划分，将满足条件的元素移动到序列的前面。
stable_partition()

查找和替换：
find（）
binary_search() 在一个已经有顺序的序列上查找。
find_if()
search() 检查第二个序列是否在第一个序列中出现，且顺序相同。

删除：注意必须调用erase（）来真正删除
remove（）
unique（）删除相邻重复元素，最好现排序。

合并序列：
merge（）

数值算法：
accumulate（） 对序列的每个元素进行运算后求和。
transform（） 也可以对每个元素进行运算。
计数：
size（）总个数。
count（）等于某值的元素个数。

adjacent_difference 序列中的后一个减前与他相邻的前一个得到新的序列。

adiacent_find

 accumlate ： iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。 

adjacent_different ：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。 
adjacent_find ：在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一个元素。否则返回 last 。重载版本使用输入的二元操作符代替相等的判断。 
binary_search ：在有序序列中查找 value ，如果找到返回 true 。重载的版本使用指定的比较函数对象或者函数指针来判断相等。 
copy ：复制序列。 
copy_backward ：除了元素以相反的顺序被拷贝外，别的和 copy 相同。 
count ：利用等于操作符，把标志范围类的元素与输入的值进行比较，并返回相等元素的个数。 
count_if ：对于标志范围类的元素，应用输入的操作符，并返回结果为 true 的次数。 
equal ：如果两个序列在范围内的元素都相等，则 equal 返回 true 。重载版本使用输入的操作符代替了默认的等于操作符。 
equal_range ：返回一对 iterator ，第一个 iterator 表示由 lower_bound 返回的 iterator ，第二个表示由 upper_bound 返回的 iterator值。 
fill ：将输入的值的拷贝赋给范围内的每个元素。 
fill_n ：将输入的值赋值给 first 到 frist+n 范围内的元素。 
find ：利用底层元素的等于操作符，对范围内的元素与输入的值进行比较。当匹配时，结束搜索，返回该元素的一个 InputIterator 。 
find_if ：使用输入的函数替代了等于操作符执行了 find 。 
find_end ：在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”的最后一次出现。重载版本中使用了用户输入的操作符替代等于操作。 
find_first_of ：在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”中的任意一个元素的第一次出现。重载版本中使用了用户自定义的操作符。 
for_each ：依次对范围内的所有元素执行输入的函数。 
generate ：通过对输入的函数 gen 的连续调用来填充指定的范围。 
generate_n ：填充 n 个元素。 
includes ：判断 [first1, last1) 的一个元素是否被包含在另外一个序列中。使用底层元素的 <= 操作符，重载版本使用用户输入的函数。 
inner_product ：对两个序列做内积 ( 对应的元素相乘，再求和 ) ，并将内积加到一个输入的的初始值上。重载版本使用了用户定义的操作。 
inner_merge ：合并两个排过序的连续序列，结果序列覆盖了两端范围，重载版本使用输入的操作进行排序。 
iter_swap ：交换两个 ForwardIterator 的值。 
lexicographical_compare ：比较两个序列。重载版本使用了用户自定义的比较操作。 
lower_bound ：返回一个 iterator ，它指向在范围内的有序序列中可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用了自定义的比较操作。 
max ：返回两个元素中的较大的一个，重载版本使用了自定义的比较操作。 
max_element ：返回一个 iterator ，指出序列中最大的元素。重载版本使用自定义的比较操作。 
min ：两个元素中的较小者。重载版本使用自定义的比较操作。 
min_element ：类似与 max_element ，不过返回最小的元素。 
merge ：合并两个有序序列，并存放到另外一个序列中。重载版本使用自定义的比较。 
mismatch ：并行的比较两个序列，指出第一个不匹配的位置，它返回一对 iterator ，标志第一个不匹配的元素位置。如果都匹配，返回每个容器的 last 。重载版本使用自定义的比较操作。 
next_permutation ：取出当前范围内的排列，并将其重新排序为下一个排列。重载版本使用自定义的比较操作。 
nth_element ：将范围内的序列重新排序，使所有小于第 n 个元素的元素都出现在它前面，而大于它的都出现在后面，重载版本使用了自定义的比较操作。 
partial_sort ：对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本使用自定义的比较操作。 
partial_sort_copy ：与 partial_sort 相同，除了将经过排序的序列复制到另外一个容器。 
partial_sum ：创建一个新的元素序列，其中每个元素的值代表了范围内该位置之前所有元素之和。重载版本使用了自定义操作替代加法。 
partition ：对范围内元素重新排序，使用输入的函数，把计算结果为 true 的元素都放在结果为 false 的元素之前。 
prev_permutation ：取出范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回 false 。重载版本使用自定义的比较操作。 
random_shuffle ：对范围内的元素随机调整次序。重载版本输入一个随机数产生操作。 
remove ：删除在范围内的所有等于指定的元素，注意，该函数并不真正删除元素。内置数组不适合使用 remove 和 remove_if 函数。 
remove_copy ：将所有不匹配的元素都复制到一个指定容器，返回的 OutputIterator 指向被拷贝的末元素的下一个位置。 
remove_if ：删除所有范围内输入操作结果为 true 的元素。 
remove_copy_if ：将所有不匹配的元素拷贝到一个指定容器。 
replace ：将范围内的所有等于 old_value 的元素都用 new_value 替代。 
replace_copy ：与 replace 类似，不过将结果写入另外一个容器。 
replace_if ：将范围内的所有操作结果为 true 的元素用新值替代。 
replace_copy_if ：类似与 replace_if ，不过将结果写入另外一个容器。 
reverse ：将范围内元素重新按反序排列。 
reverse_copy ：类似与 reverse ，不过将结果写入另外一个容器。 
rotate ：将范围内的元素移到容器末尾，由 middle 指向的元素成为容器第一个元素。 
rotate_copy ：类似与 rotate ，不过将结果写入另外一个容器。 
search ：给出了两个范围，返回一个 iterator ，指向在范围内第一次出现子序列的位置。重载版本使用自定义的比较操作。 
search_n ：在范围内查找 value 出现 n 次的子序列。重载版本使用自定义的比较操作。 
set_difference ：构造一个排过序的序列，其中的元素出现在第一个序列中，但是不包含在第二个序列中。重载版本使用自定义的比较操作。 
set_intersection ：构造一个排过序的序列，其中的元素在两个序列中都存在。重载版本使用自定义的比较操作。 
set_symmetric_difference ：构造一个排过序的序列，其中的元素在第一个序列中出现，但是不出现在第二个序列中。重载版本使用自定义的比较操作。 
set_union ：构造一个排过序的序列，它包含两个序列中的所有的不重复元素。重载版本使用自定义的比较操作。 
sort ：以升序重新排列范围内的元素，重载版本使用了自定义的比较操作。 
stable_partition ：与 partition 类似，不过它不保证保留容器中的相对顺序。 
stable_sort ：类似与 sort ，不过保留相等元素之间的顺序关系。 
swap ：交换存储在两个对象中的值。 
swap_range ：将在范围内的元素与另外一个序列的元素值进行交换。 
transform ：将输入的操作作用在范围内的每个元素上，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定的容器。 
unique ：清除序列中重复的元素，和 remove 类似，它也不能真正的删除元素。重载版本使用了自定义的操作。 
unique_copy ：类似与 unique ，不过它把结果输出到另外一个容器。 
upper_bound ：返回一个 iterator ，它指向在范围内的有序序列中插入 value 而不破坏容器顺序的最后一个位置，该位置标志了一个大于 value 的值。重载版本使用了输入的比较操作。 
堆算法： C++ 标准库提供的是 max-heap 。一共由以下 4 个泛型堆算法。 
make_heap ：把范围内的元素生成一个堆。重载版本使用自定义的比较操作。 
pop_heap ：并不是真正的把最大元素从堆中弹出，而是重新排序堆。它把 first 和 last-1 交换，然后重新做成一个堆。可以使用容器的 back 来访问被“弹出“的元素或者使用 pop_back 来真正的删除。重载版本使用自定义的比较操作。 
push_heap ：假设 first 到 last-1 是一个有效的堆，要被加入堆的元素在位置 last-1 ，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较。 
sort_heap ：对范围内的序列重新排序，它假设该序列是个有序的堆。重载版本使用自定义的比较操作。