网路摘抄【3】

1、使用全局对象的构造函数在程序启动前调用函数

　　有一些应用程序需要在主程序启动前调用其它函数。如：转态过程函数、登记功能函数都是必须在实际程序运行前被调用的。最简单的办法是通过一个全局对象的构造函数来调用这些函数。因为全局对象都是在主程序开始前被构造，这些函数都将会在 main()之前返回结果。如：  
class Logger
{
　public:
　Logger()
　　{
　　　activate_log();//译者注：在构造函数中调用你需要先运行的函数
　　}
};
Logger log; //一个全局实例
int main()
{
　record * prec=read_log();//译者注：读取log文件数据
　//.. 程序代码
}  
　　全局对象log在main()运行之前被构造，log调用了函数activate_log()。从而，当main()开始执行时，它就可以从log文件中读取数据。

　　毫无疑问地，在C++编程中内存管理是最复杂和最容易出现bug的地方。直接访问原始内存、动态分配存储和最大限度的发挥C++指令效率，都使你必须尽力避免有关内存的bug。

2、 指向成员的指针

　　一个类有两种基本的成员：函数成员和数据成员。同样的，指向成员的指针也有两种：指向函数成员的指针和指向数据成员的指针。后则其实并不常用，因为类一般是不含有公共数据成员的，仅当用在继承用C写的代码时协调结构（struct)和类(class)时才会用到。

　　指向成员的指针是C++语法中最难以理解的构造之一，但是这也是一个C++最强大的特性。它可以让你调用一个类的函数成员而不必知道这个函数的名字。这一个非常敏捷的调用工具。同样的，你也可以通过使用指向数据成员的指针来检查并改变这个数据而不必知道它的成员名字。
　　指向数据成员的指针

　　尽管刚开始时，指向成员的指针的语法会使你有一点点的迷惑，但你不久会发现它其实同普通的指针差不多，只不过是*号的前面多了::符号和类的名字，例：定义一个指向int型的指针：  
int * pi;   
　　定义一个指向为int型的类的数据成员：  
int A::*pmi; //pmi是指向类A的一个int型的成员  
　　你可以这样初始化它：  
class A
{
　public:
　int num;
　int x;
};
int A::*pmi = & A::num;   
　　上面的代码是声明一个指向类A的一个int型的num成员并将它初始化为这个num成员的地址.通过在pmi前面加上*你就可以使用和更改类A的num成员的值：  
A a1, a2;
int n=a1.*pmi; //把a1.num赋值给n
a1.*pmi=5; // 把5赋值给a1.num
a2.*pmi=6; // 把6赋值给6a2.num   
　　如果你定义了一个指向类A的指针，那么上面的操作你必须用 ->*操作符代替：  
A * pa=new A;
int n=pa->*pmi;
pa->*pmi=5;   

　　指向函数成员的指针

　　它由函数成员所返回的数据类型构成，类名后跟上::符号、指针名和函数的参数列表。举个例子：一个指向类A的函数成员（该函数返回int类型）的指针：  
class A
{
　public:
　int func ();
};
int (A::*pmf) ();   
　　上面的定义也就是说pmf是一个指向类A的函数成员func()的指针.实际上，这个指针和一个普通的指向函数的指针没什么不同，只是它包含了类的名字和::符号。你可以在在任何使用*pmf的地方调用这个函数  
func()：
pmf=&A::func;
A a;
(a.*pmf)(); //调用a.func()  
　　如果你先定义了一个指向对象的指针，那么上面的操作要用->*代替：  
A *pa=&a;
(pa->*pmf)(); //调用pa->func()  
　　指向函数成员的指针要考虑多态性。所以，当你通过指针调用一个虚函数成员时，这个调用将会被动态回收。另一个需要注意的地方，你不能取一个类的构造函数和析构函数的地址。

3、是delete还是delete[]

　　在程序员中有个荒诞的说法：使用delete来代替delete[]删除数组类型时是可以的！
　　举个例子吧：  
　int *p=new int[10];
　delete p; //错误，应该是：delete[] p  
　上面的程序是完全错误的。事实上，在一个平台上使用delete代替delete[]的应用程序也许不会造成系统崩溃，但那纯粹是运气。你不能保证你的应用程序是不是会在另一个编译器上编译，在另一个平台上运行，所以还是请使用delete[]。

4、 优化成员的排列

　　一个类的大小可以被下面的方式改变：  
struct A
{
　bool a;
　int b;
　bool c;
}; //sizeof (A) == 12  
　　在我的电脑上sizeof (A) 等于12。这个结果可能会让你吃惊，因为A的成员总数是6个字节：1+4+1个字节。那另6字节是哪儿来的？编译器在每个bool成员后面都插入了3个填充字节以保证每个成员都是按4字节排列，以便分界。你可以减少A的大小，通过以下方式：  
struct B
{
　bool a;
　bool c;
　int b;
}; // sizeof (B) == 8  
　　这一次，编译器只在成员c后插入了2个字节。因为b占了4个字节，所以就很自然地把它当作一个字的形式排列，而a和c的大小1+1=2，再加上2个字节就刚好按两个字的形式排列B。  

5、为什么继承一个没有虚析构函数的类是危险的？

　　一个没有虚析构函数的类意味着不能做为一个基类。如std::string, std::complex, 和 std::vector 都是这样的。为什么继承一个没有虚析构函数的类是危险的？当你公有继承创建一个从基类继承的相关类时，指向新类对象中的指针和引用实际上都指向了起源的对象。因为析构函数不是虚函数，所以当你delete一个这样的类时，C++就不会调用析构函数链。举个例子说明：  
class A
{
　public:
　~A() // 不是虚函数
　{
　// ...
　}
};
class B: public A //错; A没有虚析构函数
{
　public:
　~B()
　{
　// ...
　}
};
int main()
{
　A * p = new B; //看上去是对的
　delete p; //错，B的析构函没有被调用
}   

6、以友元类声明嵌套的类

　　当你以友元类声明一个嵌套的类时，把友元声明放在嵌套类声明的后面，而不前面。  
class A
{
　private:
　int i;
　public:
　class B //嵌套类声明在前
　{
　　public:
　　B(A & a) { a.i=0;};
　};
　friend class B;//友元类声明
};  
　　如果你把友元类声明放在声明嵌套类的前面，编译器将抛弃友元类后的其它声明。