ldd查看应用程序链接了哪些动态库。

nm列出目标文件中包含的符号信息。

size列出各个段的大小及总的大小。

strings列出文件中的字符串。

readelf读取elf文件的完整结构。

objdump导出目标文件的相关信息（elf文件相关工具的源头）。

gdb对文件的执行过程进行调试分析，设置断点(b)、单步执行(n)、函数调用追踪(bt)、反汇编(disassemble)。

strace跟踪程序中的系统调用及信号处理信息。

LD_DEBUG通过设置这个环境变量，可以方便的看到 loader 的加载过程（包括库的加载，符号解析等过程），使用【LD_DEBUG=help 可执行文件路径】可查看使用帮助。

LD_PRELOAD环境变量指定的共享库会被预先加载，如果出现重名的函数，预先加载的函数将会被调用，如在预先加载的库中包含自定义的puts函数，则在执行程序时将使用自定义版本的puts函数，而不是libc库中的puts函数。

proc文件系统中包含进程的地址空间映射关系，具体查看/proc/进程id/maps文件的内容。

valgrind工具对可执行程序文件进行内存检查（还有cache模拟、调用过程跟踪等功能），以避免内存泄露等问题。

addrline将可执行文件中的地址转换为其在源文件中对应的位置（文件名：行号）。

前提:

下载stl源码：  http://www.sgi.com/tech/stl/download.html
打开网页：     http://www.sgi.com/tech/stl/stl_index.html

一   函数对象： 因为很多的算法中多使用了函数对象

二元函数对象，V1和V2为输入，V3为结果

plus<T>:
  transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),plus<double>());

其他的二元函数对象：minus,multiples,divieds,modulus.

二元断言函数对象，使用时需要bind2nd（）或bind1st（）来绑定比较对象。

less<T>:
  find_if(L.begin(), L.end(), bind2nd(less<int>(), 0));

其他的二元断言函数：equal_to,notequal_to,greater,greater_equal,less_equal,logical_and,logical_or

二元逻辑函数

binary_negate:
const char* wptr = find_if(str, str + MAXLEN,
                           compose2(not2(logical_or<bool>()),
                                    bind2nd(equal_to<char>(), ' '),
                                    bind2nd(equal_to<char>(), '"n')));

一元函数对象

negate：
transform(V1.begin(), V1.end(), V2.begin(),
          negate<int>());

一元断定函数对象

logical_not:
  transform(V.begin(), V.end(), V.begin(), logical_not<bool>());

一元逻辑函数

unary_negate:

二   函数对象发生器：主要用来填充序列。


产生不重复的随机数：
// Generate unique random numbers from 0 to mod:
class URandGen {
  std::set<int> used;
  int limit;
public:
  URandGen(int lim) : limit(lim) {
    srand(time(0));
  }
  int operator()() {
    while(true) {
      int i = int(rand()) % limit;
      if(used.find(i) == used.end()) {
        used.insert(i);
        return i;
      }
    }
  }
};

const int sz = 10;
const int max = 50;
vector<int> x(sz), y(sz), r(sz);
//An integer random number generator:
URandGen urg(max);
generate_n(x.begin(), sz, urg);

三 函数对象适配器 ： 将函数转化为函数对象

ptr_fun:一般函数适配器

一元实例：
transform(first, last, first,
          compose1(negate<double>, ptr_fun(fabs)));

二元实例：
list<char*>::iterator item =
              find_if(L.begin(), L.end(),
                      not1(binder2nd(ptr_fun(strcmp), "OK")));

not1：对一元的断定函数对象取反的适配器。

not2: 对二元的断定函数对象取反的适配器。

mem_fun与mem_fun_ref：类成员函数的适配器,区别是一个需要指针，而另一个仅需要一般对象。如下：
shape是一个指针变量，则foreach(v.begin(),v.end(),mem_fun(&shape::draw));
但如果shape是一般的变量，不是指针，则foreach（v.begin(),v.end(),mem_fun_ref(&shape::draw)）；

四   算法：

拷贝：
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 ：对范围内的序列重新排序，它假设该序列是个有序的堆。重载版本使用自定义的比较操作。

接下来： STL容器学习

插入迭代器

插入迭代器是一种迭代器适配器，带有一个容器参数，并生成一个迭代器，用于在指定的容器中插入元素。通过插入迭代器赋值时，迭代器将会插入一个新的元素。C++语言提供了三种插入器，其差别在于插入元素的位置不同：

#include <setjmp.h>

            int setjmp(jmp_buf env）

void longjmp(jmp_buf env, int val);

      longjmp注意：
1.不要假象寄存器类型的变量将总会保持不变。在调用longjmp之后，通过setjmp所返回的控制流中，例程中寄存器类型的变量将不会被恢复。
2.不要使用longjmp函数来实现把控制流，从一个中断处理例程中传出，除非被捕获的异常是一个浮点数异常。在后一种情况下，如果程序通过调用 _fpreset函数，来首先初始化浮点数包后，它是可以通过longjmp来实现从中断处理例程中返回。
3. 在C++程序中，小心对setjmp和longjmp的使用，应为setjmp和longjmp并不能很好地支持C++中面向对象的语义。因此在C++程 序中，使用C++提供的异常处理机制将会更加安全。把setjmp和longjmp组合起来，原来它这么厉害！

1. 在嵌入式系统中，有时core dump直接从串口打印出来，结合objdump查找ra和epa地址，运用栈回溯，可以找到程序出错的地方。

2. 在一般Linux系统中，默认是不会产生core dump文件的，通过ulimit -c来查看core dump文件的大小，一般开始是0，可以设置core文件大小，ulimit -c 1024(kbytes单位)或者ulimit -c unlimited。

3. core dump文件输出设置，一般默认是当前目录，可以在/proc/sys/kernel中找到core-user-pid，通过

echo "1" > /proc/sys/kernel/core-user-pid使core文件名加上pid号，还可以用

mkdir -p /root/corefile

echo "/root/corefile/core-%e-%p-%t" > /proc/sys/kernel/core-pattern控制core文件保存位置和文件名格式。

以下是参数列表:
    %p - insert pid into filename 添加pid
    %u - insert current uid into filename 添加当前uid
    %g - insert current gid into filename 添加当前gid
    %s - insert signal that caused the coredump into the filename 添加导致产生core的信号
    %t - insert UNIX time that the coredump occurred into filename 添加core文件生成时的unix时间
    %h - insert hostname where the coredump happened into filename 添加主机名
    %e - insert coredumping executable name into filename 添加命令名


4. 用gdb查看core文件:
下面我们可以在发生运行时信号引起的错误时发生core dump了.编译时加上-g
发生core dump之后, 用gdb进行查看core文件的内容, 以定位文件中引发core dump的行.
gdb [exec file] [core file]
如:
gdb ./test test.core
在进入gdb后, 用bt命令查看backtrace以检查发生程序运行到哪里, 来定位core dump的文件行.

5. 给个例子

test.c

void a()

{

   char *p = NULL;

   printf("%d\n", *p);

}

int main()

{

    a();

    return 0;

}

编译 gcc -g -o test test.c

运行 ./test

报segmentation fault(core dump)

gdb ./test test.core如果生成的是test.core.

4.2.3 Defined The special operator defined is used in #if and #elif expressions to test whether a certain name is defined as a macro. defined name and defined (name) are both expressions whose value is 1 if name is defined as a macro at the current point in the program, and 0 otherwise. Thus, #if defined MACRO is precisely equivalent to #ifdef MACRO.

defined is useful when you wish to test more than one macro for existence at once. For example,

#if defined (__vax__) || defined (__ns16000__)

would succeed if either of the names __vax__ or __ns16000__ is defined as a macro.

Conditionals written like this:

#if defined BUFSIZE && BUFSIZE >= 1024

can generally be simplified to just #if BUFSIZE >= 1024, since if BUFSIZE is not defined, it will be interpreted as having the value zero.

int getch(void)　　　　//从标准输入读入一个字符，当你用键盘输入的时候，屏幕不显示你所输入的字符。也就是，不带回显。
int getche(void) 　　　//从标准输入读入一个字符，键盘输入的时候，屏幕显示所输入的字符。带回显。

这两个函数包含在头文件conio.h中，需要记住的是conio.h不是C标准库中的头文件。Micorsoft 和 Borland的 C编译器提供了conio.h，用来创建控制台文本用户界面。一般在Windows系统下安装了VS、VC等，就可以包含conio.h头文件。但是一般 在Unix、Linux系统中，/usr/include/中都没有这个头文件。

getch和getche在等待用户从键盘输入的时候，用户按下一个键后，不需要按回车，程序自动往下执行。在Linux中，终端输入在缺省情况下是被“一锅端”的，也就是说整行输入是被一起处理的。通常，这是一种人们所希望的方便的办法，但它也意味着在读入数据时必须按一下回车键表示输入行结束后才能得到输入的数据。在游戏中，很多都提供了“老板键”，它的实现，就是利用了这两个函数。

其次，除了getch和getche，其他的都是C标准库中的头文件，包含在头文件stdio.h中。

int fgetc ( FILE * stream ); //从流stream中读一个字符。可以将标准输入stdin作为它的实参，这时候从标准输入读取一个字符。

int getc(FILE * stream);     //和fgetc等效，由fgetc通过宏实现。

int getchar ( void );　　　　 //从标准输入stdin读入一个字符，程序等待你输入的时候，你可以输入多个字符，回车后程序继续执行。
                                 //但getchar只读入一个字符
说明:getc、getchar都是通过宏定义借助fgetc实现。如getchar的实现为，#define getchar() fgetc(stdin)。
 
char * fgets (char * str, int num, FILE *stream);
　　　　　　　　　　　　　　　　 //从流stream中读入最多num个字符到字符数组str中，当遇到换行符时、或读到num-1个字符时停止。
　　　　　　　　　　　　　　　　 //自动加上'\0'空字符结尾

char * gets ( char * str );　//从标准输入stdin读取一个字符串，遇到换行或结束时候终止。

　　　　　　　　　　　　　　　　 //不同于fgets，他没有指定num，所以需要注意字符数组str的大小。

说明： fgets和gets之间没有宏定义的关系，彼此各自有自己的实现。蠕虫病毒的实现就是函数gets的“功劳”。gets函数的任务是从流中读入一个字符串。它的调用者会告诉它把读入的字符串放在什么地方。但是，gets()函数并不检查缓冲区大小，如果调用者提供了一个指向堆栈的指针，并且get()函数读入的字符数量超过了超过了缓冲区的空间大小，get()会愉快地将多出来的字符继续写入到堆栈中，这就覆盖了堆栈中原来的内容。如：


main()

{

   char line[512];    //在程序的堆栈上分配512个字符的空间

   ...

   gets(line);        //蠕虫病毒的入口，可以将恶意代码通过多出来的数据写入堆栈

}

 

建议不要用getch和getche，因为它们不是C标准库中的函数。用它们写出的程序可移植性差，不同的编译器不保证可以包含conio.h。建议用fgets函数彻底替代gets函数。

另外，绝大多数的这些get函数，都有对应的put版本。

int fputc ( int character, FILE * stream );

int putc ( int character, FILE * stream );       //通过宏定义和fputc实现

int putchar ( int character );　　　　　　　　//通过宏定义实现：#define putchar(c) fputc(c, stdout)

int fputs ( const char * str, FILE * stream );

int puts ( const char * str );

说明：两者之间无宏定义实现关系。puts(const char *str)近似等效于fputs(cosnt char *str, stdout)，不同点是前者还输出一个'\n'

最后，关于EOF

EOF是在stdio.h文件中定义的符号常量，值为-1。如，

fputc函数返回一个值：如果输出成功则返回值就是输出的字符；如果输出失败，则返回一个EOF。 

fgetc函数读字符时遇到文件结束符，函数返回一个文件结束标记EOF。如果想从一个磁盘文件顺序读入字符并在屏幕上显示，可以：

注意，EOF不是可输出字符，因此不能在屏幕上显示。由于ASCII码不可能出现-1，因此EOF定义为-1是合适的。当读入的字符值等于-1（即 EOF）时，表示读入的已不是正常的字符，而是文件结束符。但以上只适用于读取文本文件的情况。现在ANSI C 已经允许用缓冲文件系统处理二进制文件，而读入某一个字节中的二进制数据的值有可能是-1，而这又恰好是EOF的值。这就出现了需要读入有用数据，却处理 为“文件结束”。feof(fp) 用来测试fp所指向的文件当前状态是否是“文件结束”。如果想顺序读入一个二进制文件数据，可以：

例一：
Declaration.
A construct which associates attributes to a variable name or function. No storage is reserved. For example:
extrn int a;
extrn char c;
variable declaration A structure decleration could look like:

 Definition.
Variable definition is a declaration with storage allocation.

struct per_rec {      int age;     char *surname;     char *firstname; };

int a; char c; struct per_rec person;

A construct which specifies the name,parameters and return type of a function. For example a function definition would be:

{
 3public :
 4    Test( int ) {}
 5    Test() {}
 6    void fun() {}
 7
 8    int i;
 9}

{
12    Test a(1);
13    Test b();
14
15    a.fun();
16    b.fun();
17}

--------------------Configuration: hex - Win32 Debug--------------------
Compiling...
hex.cpp
E:\Projects\C++\Hex\hex.cpp(42) : error C2228: left of '.fun' must have class/struct/union type
Error executing cl.exe.

hex.exe - 1 error(s), 0 warning(s)

Cpp代码

1. #include <iostream>   
2. #include <stdexcept>   
3. using namespace std ;   
4.   
5. int main ()   
6. {   
7.     try  
8.     {   
9.         int* p=NULL;   
10.         while(1)   
11.             p=new int[10000];   
12.     }catch(std::bad_alloc&)   
13.     {   
14.         cout<<"no enough mem."<<endl;   
15.     }   
16.     return 0 ;   
17. }  

#include <iostream>
#include <stdexcept>
using namespace std ;
int main ()
{
try
{
int* p=NULL;
while(1)
p=new int[10000];
}catch(std::bad_alloc&)
{
cout<<"no enough mem."<<endl;
}
return 0 ;
}

2,C++的一个公约:
当operator new无法满足需求时,它会在抛出exception前先调用一个专属的错误处理函数.
我们称之为:new-handler.

3,当operator无法满足内存需求时,它会不只一次的调用new-handler函数;
它会不断的重复调用,直到找到足够的内存.
一个设计良好的new-handler函数必须完成下面几件事:
(1)让更多内存可用.
例如:事先在程序起始处配置一大块内存,然后在new-handler第一次被调用时释放之.
(2)配置另外一个new-handler,其手上握有比较多的资源.
(3)卸除new-handler,set_new_handler(NULL)
将不再调用专属函数,而直接抛出exception.
(4)抛出exception.
(5)不回返,直接调用abort()或exit.

Cpp代码

1. #include <iostream>   
2. #include <stdexcept>   
3. using namespace std ;   
4.   
5. void noMoreMemory()   
6. {   
7.     cout<<"Unable to satify request for memory."<<endl;   
8.     //原则(5):不回返   
9.     abort();//不加,将会是一个死循环.   
10.     //原则(4):也可以通过抛出一个异常   
11.     //throw std::bad_alloc();   
12. }   
13.   
14. int main ()   
15. {   
16.     //typedef void (*new_handler)();  头文件中已经给出   
17.     //设定自己的专属错误处理函数.   
18.     //返回之前的new_handler   
19.     new_handler old_new_handler=set_new_handler(noMoreMemory);   
20.     //set_new_handler(NULL); //卸除new-handler,抛出异常.   
21.     try  
22.     {   
23.         int* p=NULL;   
24.         while(1)   
25.             p=new int[10000];   
26.     }catch(std::bad_alloc&)   
27.     {   
28.         cout<<"no more memory."<<endl;   
29.         set_new_handler(old_new_handler);   
30.     }   
31.     set_new_handler(old_new_handler);   
32.     return 0 ;   
33. }  

#include <iostream>
#include <stdexcept>
using namespace std ;
void noMoreMemory()
{
cout<<"Unable to satify request for memory."<<endl;
//原则(5):不回返
abort();//不加,将会是一个死循环.
//原则(4):也可以通过抛出一个异常
//throw std::bad_alloc();
}
int main ()
{
//typedef void (*new_handler)();  头文件中已经给出
//设定自己的专属错误处理函数.
//返回之前的new_handler
new_handler old_new_handler=set_new_handler(noMoreMemory);
//set_new_handler(NULL); //卸除new-handler,抛出异常.
try
{
int* p=NULL;
while(1)
p=new int[10000];
}catch(std::bad_alloc&)
{
cout<<"no more memory."<<endl;
set_new_handler(old_new_handler);
}
set_new_handler(old_new_handler);
return 0 ;
}

4,设定类class专属的new-handler.
一个强大的类模板.

Cpp代码

1. #include <iostream>   
2. #include <stdexcept>   
3. using namespace std ;   
4.   
5. template<class T>   
6. class NewHandlerSupport   
7. {   
8. public:   
9.     static new_handler set_new_handler(new_handler p);   
10.     static void* operator new(size_t size);   
11.     static void* operator new[](size_t size);   
12. private:   
13.     static new_handler currentHandler;   
14. };   
15.   
16. template<class T>   
17. new_handler NewHandlerSupport<T>::set_new_handler(new_handler p)   
18. {   
19.     new_handler oldHandler=currentHandler;   
20.     currentHandler=p;   
21.     return oldHandler; //返回之前的专属函数   
22. }   
23.   
24. template<class T>   
25. void* NewHandlerSupport<T>::operator new(size_t size)   
26. {   
27.     //下面调用标准的set_new_handler   
28.     new_handler globalHandler=std::set_new_handler(currentHandler);   
29.   
30.     void* memory;   
31.     try  
32.     {   
33.         //使用标准的new.   
34.         memory=::operator new(size);   
35.     }catch(std::bad_alloc)   
36.     {   
37.         std::set_new_handler(globalHandler);   
38.         throw; //继续抛出异常   
39.     }   
40.   
41.   
42.     std::set_new_handler(globalHandler); //返回原来的设置   
43.     return memory; //返回之前的专属函数   
44. }   
45.   
46. template<class T>   
47. static void* NewHandlerSupport<T>::operator new[](size_t size)   
48. {   
49.     return operator new(size);   
50. }   
51.   
52. template<class T>   
53. new_handler NewHandlerSupport<T>::currentHandler; //设置为0   
54.   
55. void noMoreMemory()   
56. {   
57.     cout<<"Unable to satify request for memory."<<endl;   
58.     //abort();   
59.     throw std::bad_alloc();   
60. }   
61.   
62. class X : public NewHandlerSupport<X>   
63. {   
64. };   
65.   
66. int main ()   
67. {   
68.     X::set_new_handler(noMoreMemory);   
69.     try  
70.     {   
71.         X* p=NULL;   
72.         //先调用专属函数,然后有专属函数抛出异常.   
73.         while(1)   
74.             p=new X[100000];   
75.     }catch(std::bad_alloc&)   
76.     {   
77.         cout<<"no more memory."<<endl;   
78.     }   
79.   
80.     X::set_new_handler(0);   
81.     try  
82.     {   
83.         X* p=NULL;   
84.         //不再调用专属函数,直接捕获异常.   
85.         while(1)   
86.             p=new X[100000];   
87.     }catch(std::bad_alloc&)   
88.     {   
89.         cout<<"no more memory."<<endl;   
90.     }   
91.     return 0 ;   
92. }  

#include <iostream>
#include <stdexcept>
using namespace std ;
template<class T>
class NewHandlerSupport
{
public:
static new_handler set_new_handler(new_handler p);
static void* operator new(size_t size);
static void* operator new[](size_t size);
private:
static new_handler currentHandler;
};
template<class T>
new_handler NewHandlerSupport<T>::set_new_handler(new_handler p)
{
new_handler oldHandler=currentHandler;
currentHandler=p;
return oldHandler; //返回之前的专属函数
}
template<class T>
void* NewHandlerSupport<T>::operator new(size_t size)
{
//下面调用标准的set_new_handler
new_handler globalHandler=std::set_new_handler(currentHandler);
void* memory;
try
{
//使用标准的new.
memory=::operator new(size);
}catch(std::bad_alloc)
{
std::set_new_handler(globalHandler);
throw; //继续抛出异常
}
std::set_new_handler(globalHandler); //返回原来的设置
return memory; //返回之前的专属函数
}
template<class T>
static void* NewHandlerSupport<T>::operator new[](size_t size)
{
return operator new(size);
}
template<class T>
new_handler NewHandlerSupport<T>::currentHandler; //设置为0
void noMoreMemory()
{
cout<<"Unable to satify request for memory."<<endl;
//abort();
throw std::bad_alloc();
}
class X : public NewHandlerSupport<X>
{
};
int main ()
{
X::set_new_handler(noMoreMemory);
try
{
X* p=NULL;
//先调用专属函数,然后有专属函数抛出异常.
while(1)
p=new X[100000];
}catch(std::bad_alloc&)
{
cout<<"no more memory."<<endl;
}
X::set_new_handler(0);
try
{
X* p=NULL;
//不再调用专属函数,直接捕获异常.
while(1)
p=new X[100000];
}catch(std::bad_alloc&)
{
cout<<"no more memory."<<endl;
}
return 0 ;
}

5,旧的编译器:
如果内存配置失败不会抛出异常,只是返回0.
测试实例:
int* p=new (nothrow)int;
if(p==0)
cout<<"memory error;"<<endl;

Cpp代码

1. #ifdef __cplusplus   
2.     cout<<"c++"<<endl;   
3. #else   
4.     cout<<"c"<<endl;   
5. #endif  

    #ifdef __cplusplus
cout<<"c++"<<endl;
#else
cout<<"c"<<endl;
#endif

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/xiaojianpitt/archive/2009/10/30/4748427.aspx

1．  在编程序时，你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想：
   ★.如果你能把“它”看成一个独立的概念，就把它做成一个类。
   ★.如果你能把“它”看成一个独立的实体，就把它做成某个类的一个对象。
   ★.如果两个类有共同的界面，将此界面做成一个抽象类。
   ★.如果两个类的实现有某些显著的共同东西，将这些共性做成一个基类。
   ★.如果一个类是一种对象的容器，将它做成一个模板。
   ★.如果一个函数实现对某容器的一个算法，将它做成为对一族容器可用的模板函数。
   ★.如果一组类、模板等相互之间有逻辑联系，将它们放进一个名字空间里。

2．  在你定义一个并不是实现某个像矩阵或复数这样的数学对象的类时，或者定义一个低层的类型如链接表的时候：
   ★.不要使用全局数据（使用成员）。
   ★.不要使用全局函数。
   ★.不要使用公用数据成员。
   ★.不要使用友元，除非为了避免a或c。
   ★.不要在一个类里面放“类型域”（指那种为了说明一个类所存储数据的情况而放置的标志域） ；采用虚函数。
   ★.不要使用在线函数(inline function)，除非作为效果显著的优化。

二、C++ 概览

1．  不用害怕，一切都会随着时间的推移而逐渐明朗起来。
2．  你并不需要在知道了C++的所有细节之后才能写出好的C++程序。
3．  请特别关注程序设计技术，而不是各种语言特征。

三、标准库概览

1．  不要像重新发明车轮那样企图做每件事；去使用库。
2．  不要相信奇迹；要理解你的库能做什么，它们如何做，它们做时需要多大的代价。
3．  当你遇到一个选择时，应该优先选择标准库而不是其他的库。
4．  不要认为标准库对于任何事情都是最理想的。
5．  切记#include 你所用到的功能的头文件。
6．  记住，标准库的功能定义在名字空间std之中。
7．  请用string，而不是char*。
8．  如果怀疑，就用一个检查区间范围的向量（例如Vec）。
9．  vector<T> 、list<T>和 map<key,value> 都比T[] 好。
10． 如果向一个容器中添加一个元素，用push_back() 或 back_inserter()。
11． 采用对vector的push_back()，而不是对数组的realloc()。
12． 在main()中捕捉公共的异常。

四、类型和声明

1．  保持较小的作用域。
2．  不要在一个作用域和它外围的作用域里采用同样的名字。
3．  在一个声明中只声明一个名字。
4．  让常用的和局部的名字比较短，让不常用的和全局的名字比较长。
5．  避免看起来类似的名字。
6．  维持某种统一的命名风格。
7．  仔细选择名字，反映其意义而不是反映实现方式。
8．  如果所用的内部类型表示某种可能变化的值，请用typedef 为它定义一个有意义的名字。
9．  用typedef为类型定义同义词，用枚举或类去定义新类型。
10． 切记每个声明中都必须描述一个类型（没有“隐式的int”）。
11． 避免有关字符数值的不必要假设。
12． 避免有关整数大小的不必要假设。
13． 避免有关浮点类型表示范围的不必要假设。
14． 优先使用普通的int 而不是short int 或者long int。
15． 优先使用double 而不是float 或者long double。
16． 优先使用普通的 char 而不是 signed char或者 unsigned char。
17． 避免做出有关对象大小的不必要假设。
18． 避免无符号算术。
19． 应该带着疑问去看待从signed 到unsigned ，或者从unsigned 到signed 的转换。
20． 应该带着疑问去看待从浮点到整型的转换。
21． 应该带着疑问去看待向较小类型的转换，如将int转换到char。

五、忠告

1．  避免非平凡的指针算术。
2．  当心，不要超出数组的界线去写。
3．  尽量使用0而不是NULL。
4．  尽量使用vector 和valarray ，而不是内部（C风格）的数组。
5．  尽量使用string而不是以0结尾的char 数组。
6．  尽量少用普通的引用参数。
7．  避免 void*，除了在某些低级代码里。
8．  避免在代码中使用非平凡的文字量（“神秘的数”）。相反，应该定义和使用各种符号常量。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/youki1234/archive/2005/01/29/273434.aspx

#include<iostream>
#include<string>
using namespace std;

namespace NS
{
        string x="namespace NS";
}

string x="global scope";

class A
{
        string x;
public:
        A():x("class scope"){};

        void f(){
                string x="local scope";
                cout<<x<<endl;
        }
        void g(){
                cout<<x<<endl;
 }
};

class B
{
        public:
                void f()
                {
                        cout<<x<<endl;
                }
                void g()
                {
                        cout<<NS::x<<endl;
                }
};

int main()
{
        A a;
        B b;
        a.f();a.g();
        b.f();b.g();
}

• 首先调用local scope的
• 接着调用class scope的
• 最后才调用global scope的
• 如果直接有用限定符，则调用限定符的，无论是namespace 限定符还是class限定符

函数名字的查找，除了local scope的，基本同上，有一点例外的是，则在下面ADL中说明

2.关联名字查找 (Argument Dependent Lookup)
在说明前要明确2个概念

• 关联(dependent name)：不能解析的名字就叫关联名，这个一般同模版有关，比如template<class T> A{T t;}; 中，t就是关联名，它在模版编译的第一阶段是无法解析的，只有到第二阶段，用实际参数来实例化的时候才知道 
• 限定名(qualified name): 指变量名或函数名前有类名前缀，或者被对象，指针修饰： Class::f() //类名前缀  x.f() //对象修饰 p->f() //指针修饰

而ADL要解决的问题是对非限定名的查找问题（限定名可以根据相应的限定来查找）： 当出现了对某个非限定函数的调用，而该非限定函数却没有在一个（标准）作用域内进行声明时（简单的讲，该函数只声明在某个namespace，而你又没有引入这个namespace)，编译器就会寻找它的每一个参数的名字空间来进行匹配。ADL是为了简化函数调用，不过事实上它有点破坏了namespace的封装。
比如以下函数调用
   std::string s("hello");
   std::cout<<s<<std::endl;
程序中没有指定使用哪一个operator<<函数，程序员当然不想输入
  std::operator<<(std::operator(std::cout,s),std::endl);
这时，ADL根据s查找s的namespace,并查找相应的operator<<

ADL ，参数相关查找，也称作为 Koenig 查找（以 Andrew Koenig 的名字命名），是指在编译器对无限定域的函数调用进行名字查找时，所应用的一种查找规则。

首先来看一个函数所在的域的分类：

1 ：类域（函数作为某个类的成员函数（静态或非静态））

2 ：名字空间域

3 ：全局域

而 Koenig 查找，它的规则就是当编译器对无限定域的函数调用进行名字查找时，除了当前名字空间域以外，也会把函数参数类型所处的名字空间 加入查找的范围。

ADL 就是为了确保使用类型 X 的对象 x 时能够像使用 X 的成员函数一样简单 (ensure that code that uses an object x of type X can use its nonmember function interface as easily as it can use member functions) 。

根据 ADL 规则，如果非成员函数想和类型一起被使用，应该将它们置于同一个名字空间中。换句话说，和类型 X 放在同一名字空间下的非成员函数，也是 X 接口的一部分。 ( 常见的有 <<or>> 操作符 )

示例：

#include <iostream>

//class N     // 类域

//{

//public :

//     enum E {e1};

//     void f(E)

//     {

//            std::cout << "N::f(N::E) called\n";

//     }

//};

namespace N{   // 名字空间域

       enum E {e1};

       void f(E){

              std::cout << "N::f(N::E) called\n";

       }

}

void f(int)

{

       std::cout << " ::f(int) called\n";

}

int main()

{

       ::f(N::e1);     // 受限函数，禁用 ADL  // 输出 ::f(int) called

       f(N::e1);      // 普通查找到 f();

       return 0;

}

上述例子，如果 N 为 class ，输出为： ::f(int) called ；如果 N 为名字空间，输出： N::f(N::E) called 。

也就是说 ADL 仅会将参数所在的名字空间中的函数名字加入查找范围。

调用函数时，显式地限定名字空间将禁用 ADL 查找 ，加快解析过程。

Argument Dependent Lookup (ADL)解析

ADL，参数相关查找，也称作为Koenig查找（以Andrew Koenig的名字命名，有兴趣可以看Scott Meyer的文章The Most Important C++ People...Ever），是指在编译器对无限定域的函数调用进行名字查找时，所应用的一种查找规则。

f(x, y, z); // unqualified
N::f(x, y, z); // qualified

上面的函数调用，第一个f就是无限定域的函数调用，第二个则限定了在名字空间N里面，也是说使用了完全限定名。

我们首先来看一个函数所在的域的分类：

1：类域（函数作为某个类的成员函数（静态或非静态））

2：名字空间域

3：全局域

而Koenig查找，它的规则就是当编译器对无限定域的函数调用进行名字查找时，除了当前名字空间域以外，也会把函数参数类型所处的名字空间加入查找的范围。

Herb提供的解释（Exceptional C++, Item 31）

Koenig Lookup(simplified): If you supply a function argument of class type (here x, of type A::X), then to look up the correct function name the compiler considers matching names in the namespace (here A) containing the argument's type.

请看下面的例程：

#include <iostream>
usingnamespace std;

namespace Koenig
{
    class KoenigArg
    {
    public:
          ostream& print(ostream&out) const
         {
                 out<<member_<<endl;
          }

          KoenigArg(int member =5) : member_(member){}

    private:
         int member_;
     };


     inline ostream&operator<<(ostream&out, const KoenigArg& kArg)
    {
         return kArg.print(out);
     }
}

int main()
{
     Koenig::KoenigArg karg(10);
     cout<<karg;

    char c;cin>>c;

    return0;
}

我们通常都会写如上的代码，使用operator<<打印对象的状态，但是ostream& operator<<(ostream& out, const KoenigArg& kArg) 的定义是处于名字空间Koenig，为什么编译器在解析main函数（全局域）里面的operator<<调用时，它能够正确定位到Koenig名字空间里面的operator<<？这是因为根据Koenig查找规则，编译器需要把参数类型KoenigArg所在的名字空间Koenig也加入对operator<<调用的名字查找范围中。

如果没有Koenig查找规则，我们就无法直接写cout<<karg;，而是需要写类似Koenig::operator<<(std::cout, karg); 这样的代码（使用完全限定名）。嗯，即不直观也不方便是吗？更重要的是如果我们写的是模版代码，在模版参数还没有实例化之前，我们根本就不知道参数所处的名字空间，比如：

template<typename T>void print(const T& value)
{
     std::cout<<value;
}

print(karg);

很显然，你的模版代码根本无法确认T是来自那个名字空间，直到编译器对模版实例化（print(karg); 被调用）。

对Koenig查找规则的一个异议是，由于Koenig查找规则的存在，处于某个名字空间的函数调用的重载决议会受到另外一个名字空间的自由函数所影响，仅仅是由于它使用了另外一个名字空间的类型作为参数。在这样的规则下，名字空间看起来不像我们一般所想象的那样是完全封闭和独立的。

我们应该怎么解释这样的异议呢？这样隐讳的影响或者依赖性是合理的吗？Herb认为，如果我们把另外一个名字空间的自由函数（非类成员函数）也看作是它所涉及的类型的接口的一部分，很显然，它应该参与这样的重载决议，这样的跨越名字空间的影响是合理的。从而导出了Herb在传统类定义之上的一个更详细和完整的解释（请参考Exceptional C++, Item 32）。

传统的类定义：

A class describes a set of data, along with the functions that operate on that data.

一个类描述了数据的集合以及操作这些数据的函数。

Herb的类定义，称之为接口准则（Interface Principle）：

For a class X, all functions, including free functions, that both

"Mention" X

Are "supplied with" X

are logically part of X, because they form part of the interface of X.

对应类X来说，所有函数，包括自由函数，只要它们

         提及X（跟X有关）

         与X一起提供

都在逻辑上被认为是X的一部分，因为它们是X的接口的一部分。

关于Koenig查找，我们该说的都说了吗？其实未然，之前所描述的只是Koenig查找一般可能发生的状况，当Koenig查找规则和C++ 原来的Ordinal Lookup（OL，顺序查找规则）混合在一起的时候，它们之间的组合所产生的状况要比之前的例子复杂的多……

对于  .cpp  文件中调用的一个函数  (  成员函数  ),  编译器主要做了下面三件事情  :

1  名字查找  .  先在所在编译单元中可见名字实体 中进行名字查找  . (1)  类成员函数优先  (  对象所在的类  ->  基类  ).  一经找到就停止查找  . 如果没有  ,(2)  在相应的名字空间中做进一步的搜索  ;  如果还没有  ,  会根据  (3)  函数参数所在的名字空间中查找  (keoning  查找  ).

2  重载决议  .  根据所找到的名字进行重载决议  ,  根据参数最匹配原则选择相应的函数  .

3  可访问性检查  .  用以确定被选中的函数是否可以被调用  .

说明  :

1)  根据第一条  ,  显然  ,  如果类型想和非成员函数一起工作  ,  那么它们应该放在同一个名字空间中  .  比如  ,  一般类型的重载运算符和参数类型放在同一个头文件中  /  或者同一个名字空间下  .

2)  函数特化模板不参与重载决议  ,  因此  ,  如果想运用某个函数的特化  ,  最好的方法是重载该函数  ,  在实现中采用该特化来工作  .

3)  重载决议发生的可访问性检查之前  .  正因如此  ,  如果私有函数不幸参与了重载  ,  并且被选中的话  ,  最终也会出现无法访问的编译提示  .  这常常隐含二义性  ,  这样设计也不合理  .  换句话说  ,  私有参数  ,  在名字查找和重载时并非是  ”  私有的  ”.

以  c.Twice  （  21  ）的函数调用为例：

a)  名字查找：编译器会首先寻找一个至少包含一个名字为  Twice  的实体作用域（类，文件，或者名字空间），并将其中的候选实体列表。例子中，编译器首先从对象  c  所在的类实体中进行查找，找到就停止；如果没找到就会依次在其基类和外围的名字空间   中查找 ，直到找到一个至少含有一个候选函数的作用域。两点需要注意：  1)  只要找到一个实体就停止查找   ，所以并非所有的同名函数都会被考虑；  2)  参数所在名字空间也属于查找范围 (keoning  准则  )  。

b)  重载决议：从所找到的候选重载函数列表中选出唯一最佳匹配   。如不唯一，就存在二义性。注意：  1)  这是基于名字查找结果的；  2)  特化的模板函数不参与重载。

c)  可访问性检查：确定所选出的函数是否可访问。这是最后一步，晚于重载决议。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhenjing/archive/2009/06/25/4299002.aspx

// 现象
// 在构造函数A中调用重载的构造函数B
// 结论
// 在B被调用结束(A未结束)时已经有一次析构函数被调用

// 测试平台
// 1.Win2K + VC6
// 2.Linux + gcc

#include <stdio.h>

class CTest
{
public:
   CTest() {
     CTest(0);
    //已经调用析构函数
     printf("CTest()\r\n");
   }
CTest(int i) {
     CTest(i, 0);
    //已经调用析构函数
     printf("CTest(%d)\r\n", i);
}
CTest(int i, int j) {
       printf("CTest(%d, %d)\r\n", i, j);
}
virtual ~CTest(){
      m_CTestCount++;
      printf(" ~CTest() m_CTestCount = %d\r\n", m_CTestCount);
}
static int m_CTestCount;
};
int CTest::m_CTestCount = 0;
int main()
{
CTest cT;
printf("main()\r\n");
//调用析构函数
return 0;
}

/*
//程序运行输出
CTest(0, 0)
~CTest() m_CTestCount = 1
CTest(0)
~CTest() m_CTestCount = 2
CTest()
main()
~CTest() m_CTestCount = 3
//程序运行输出
*/

=======================================
出现这种结果的原因是什么呢？
       当直接调用类的构造函数时，将产生一个A类型的临时对象，然后又马上被销毁。
       所以当在构造函数A中调用构造函数B时，也不会对本类的类变量进行初始化，导致的结果就是，构造函数A调用了B之后，本类的类变量还是没有被初始化，当A继续对这些类变量进行操作时，将出现对未初始化的空间进行访问的错误。

=======================================
直接调用构造函数有没有用呢？
        既然直接调用可以产生一个临时对象，然后又马上被销毁。那么我们就可以把这种特点用于传参。
        class A 有一个构造函数 A(int x)     
        void foo(A a);
        就可以 foo(A(10));
        此外对于 vector ve; ve.push_back(A(10)); 等容器操作也是有用的。

成员函数的重载、覆盖与隐藏
成员函数的重载、覆盖（override）与隐藏很容易混淆，C++程序员必须要搞清楚
概念，否则错误将防不胜防。
8.2.1 重载与覆盖
成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
示例8-2-1 中，函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)
被Derived::g(void)覆盖。
#include <iostream.h>
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
class Derived : public Base
{
public:
virtual void g(void){ cout << "Derived::g(void)" << endl;}
};
void main(void)
{
Derived d;
Base *pb = &d;
pb->f(42); // Base::f(int) 42

pb->f(3.14f); // Base::f(float) 3.14
pb->g(); // Derived::g(void)
}
示例8-2-1 成员函数的重载和覆盖
8.2.2 令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
示例程序8-2-2（a）中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。
#include <iostream.h>
class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void g(float x){ cout << "Base::g(float) " << x << endl; }
void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
};
示例8-2-2（a）成员函数的重载、覆盖和隐藏
据作者考察，很多C++程序员没有意识到有“隐藏”这回事。由于认识不够深刻，
“隐藏”的发生可谓神出鬼没，常常产生令人迷惑的结果。
示例8-2-2（b）中，bp 和dp 指向同一地址，按理说运行结果应该是相同的，可事
实并非这样。

void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavīor depends solely on type of the object
pb->f(3.14f); // Derived::f(float) 3.14
pd->f(3.14f); // Derived::f(float) 3.14
// Bad : behavīor depends on type of the pointer
pb->g(3.14f); // Base::g(float) 3.14
pd->g(3.14f); // Derived::g(int) 3 (surprise!)
// Bad : behavīor depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
pd->h(3.14f); // Derived::h(float) 3.14
}
示例8-2-2（b） 重载、覆盖和隐藏的比较
8.2.3 摆脱隐藏
隐藏规则引起了不少麻烦。示例8-2-3 程序中，语句pd->f(10)的本意是想调用函
数Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隐藏了。由于数字10
不能被隐式地转化为字符串，所以在编译时出错。
class Base
{
public:
void f(int x);
};
class Derived : public Base
{
public:
void f(char *str);
};
void Test(void)
{
Derived *pd = new Derived;
pd->f(10); // error
}
示例8-2-3 由于隐藏而导致错误

从示例8-2-3 看来，隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由：
􀂋 写语句pd->f(10)的人可能真的想调用Derived::f(char *)函数，只是他误将参数
写错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编
译器会静悄悄地将错就错，程序员将很难发现这个错误，流下祸根。
􀂋 假如类Derived 有多个基类（多重继承），有时搞不清楚哪些基类定义了函数f。如
果没有隐藏规则，那么pd->f(10)可能会调用一个出乎意料的基类函数f。尽管隐
藏规则看起来不怎么有道理，但它的确能消灭这些意外。
示例8-2-3 中，如果语句pd->f(10)一定要调用函数Base::f(int)，那么将类
Derived 修改为如下即可。
class Derived : public Base
{
public:
void f(char *str);
void f(int x) { Base::f(x); }
};