C++编程技巧

 

C++ 编程技巧

 

纯虚函数

纯虚函数是一种特殊的虚函数，它的一般格式如下：
[code]
class < 类名 >
    {
        virtual < 类型 >< 函数名 >(< 参数表 >)=0;
        …
    };
[/code]
在许多情况下，在基类中不能对虚函数给出有意义有实现，而把它说明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。下面给出一个纯虚函数的例子。
[code]
#include <iostream.h>

class point
{
public:
point(int i=0, int j=0) { x0=i; y0=j; }
virtual void set() = 0;
virtual void draw() = 0;
protected:
  };

class line : public point
{
public:
line(int i=0, int j=0, int m=0, int n=0):point(i, j)
{
x1=m; y1=n;
}
void set() { cout<<"line::set() called./n"; }
void draw() { cout<<"line::draw() called./n"; }
protected:
int x1, y1;
};
class ellipse : public point
{
public:
ellipse(int i=0, int j=0, int p=0, int q=0):point(i, j)
{
x2=p; y2=q;
}
void set() { cout<<"ellipse::set() called./n"; }
void draw() { cout<<"ellipse::draw() called./n"; }
protected:
int x2, y2;
};

void drawobj(point *p)

{
p->draw();
}



    void setobj(point *p)
{
p->set();
}



    void main()
{
line *lineobj = new line;
ellipse *elliobj = new ellipse;
drawobj(lineobj);
drawobj(elliobj);
cout<<endl;
setobj(lineobj);
setobj(elliobj);
cout<<"/nRedraw the object.../n";
drawobj(lineobj);
drawobj(elliobj);
}
[/code]
抽象类


　　带有纯虚函数的类称为抽象类。抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，它处于继承层次结构的较上层。抽象类是不能定义对象的，在实际中为了强调一个类是抽象类，可将该类的构造函数说明为保护的访问控制权限。

　　抽象类的主要作用是将有关的组织在一个继承层次结构中，由它来为它们提供一个公共的根，相关的子类是从这个根派生出来的。

　　抽象类刻画了一组子类的操作接口的通用语义，这些语义也传给子类。一般而言，抽象类只描述这组子类共同的操作接口，而完整的实现留给子类。

　　抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出。如果派生类没有重新定义纯虚函数，而派生类只是继承基类的纯虚函数，则这个派生类仍然还是一个抽象类。如果派生类中给出了基类纯虚函数的实现，则该派生类就不再是抽象类了，它是一个可以建立对象的具体类了。

 

运算符重载

[code]
运算符重载

    多态性是面向对象程序设计的重要特征之一。它与前面讲过的封装性和继承性构成了面向对象程序设计的三大特征。这三大特征是相互关联的。封装性是基础，继承性是关键，多态性是补充，而多态又必须存在于继承的环境之中。

    所谓多态性是指发出同样的消息被不同类型的对象接收时导致完全不同的行为。这里所说的消息主要是指对类的成员函数的调用，而不同的行为是指不同的实现。利用多态性，用户只需发送一般形式的消息，而将所有的实现留给接收消息的对象。对象根据所接收到的消息而做出相应的动作 ( 即操作 ) 。

      函数重载和运算符重载是简单一类多态性。函数重载的概念及用法在《函数重载》一讲中已讨论过了，这里只作简单的补充，我们重点讨论的是运算符的重载。

      所谓函数重载简单地说就是赋给同一个函数名多个含义。具体地讲， C++ 中允许在相同的作用域内以相同的名字定义几个不同实现的函数，可以是成员函数，也可以是非成员函数。但是，定义这种重载函数时要求函数的参数或者至少有一个类型不同，或者个数不同。而对于返回值的类型没有要求，可以相同，也可以不同。那种参数个数和类型都相同，仅仅返回值不同的重载函数是非法的。因为编译程序在选择相同名字的重载函数时仅考虑函数表，这就是说要靠函数的参数表中，参数个数或参数类型的差异进行选择。

      由此可以看出，重载函数的意义在于它可以用相同的名字访问一组相互关联的函数，由编译程序来进行选择，因而这将有助于解决程序复杂性问题。如：在定义类时，构造函数重载给初始化带来了多种方式，为用户提供更大的灵活性。

下面我们重点讨论运算符重载。

运算符重载就是赋予已有的运算符多重含义。 C++ 中通过重新定义运算符，使它能够用于特定类的对象执行特定的功能，这便增强了 C++ 语言的扩充能力。

   运算符重载的几个问题

1. 运算符重载的作用是什么？

它允许你为类的用户提供一个直觉的接口。
运算符重载允许 C/C++ 的运算符在用户定义类型 ( 类 ) 上拥有一个用户定义的意义。重载的运算符是函数调用的语法修饰：

class Fred
{
public:
  // ...
};

#if 0
  // 没有算符重载：
Fred add(Fred, Fred);
  Fred mul(Fred, Fred);
Fred f(Fred a, Fred b, Fred c)
{
  return add(add(mul(a,b), mul(b,c)), mul(c,a));    // 哈哈，多可笑 ...
}
#else
// 有算符重载：
  Fred operator+ (Fred, Fred);
  Fred operator* (Fred, Fred);

  Fred f(Fred a, Fred b, Fred c)
  {
return a*b + b*c + c*a;
  }
#endif

2. 算符重载的好处是什么？

   通过重载类上的标准算符，你可以发掘类的用户的直觉。使得用户程序所用的语言是面向问题的，而不是面向机器的。
   最终目标是降低学习曲线并减少错误率。

3. 哪些运算符可以用作重载？

几乎所有的运算符都可用作重载。具体包含：
   算术运算符： +,-,*,/,%,++,--;
位操作运算符： &,|,~,^,<<,>>
   逻辑运算符： !,&&,||;
比较运算符： <,>,>=,<=,==,!=;
   赋值运算符： =,+=,-=,*=,/=,%=,&=,|=,^=,<<=,>>=;
其他运算符： [],(),->,,( 逗号运算符 ),new,delete,new[],delete[],->* 。

下列运算符不允许重载：

  .,.*,::,?:

4. 运算符重载后，优先级和结合性怎么办？

用户重载新定义运算符，不改变原运算符的优先级和结合性。这就是说，对运算符重载不改变运算符的优先级和结合性，并且运算符重载后，也不改变运算符的语法结构，即单目运算符只能重载为单目运算符，双目运算符只能重载双目运算符。

  5. 编译程序如何选用哪一个运算符函数？

运算符重载实际是一个函数，所以运算符的重载实际上是函数的重载。编译程序对运算符重载的选择，遵循着函数重载的选择原则。当遇到不很明显的运算时，编译程序将去寻找参数相匹配的运算符函数。

   6. 重载运算符有哪些限制？

(1) 不可臆造新的运算符。必须把重载运算符限制在 C++ 语言中已有的运算符范围内的允许重载的运算符之中。

(2) 重载运算符坚持 4 个 “ 不能改变 ” 。

· 不能改变运算符操作数的个数；
· 不能改变运算符原有的优先级；
  · 不能改变运算符原有的结合性；
  · 不能改变运算符原有的语法结构。

  7. 运算符重载时必须遵循哪些原则？

运算符重载可以使程序更加简洁，使表达式更加直观，增加可读性。但是，运算符重载使用不宜过多，否则会带来一定的麻烦。
   使用重载运算符时应遵循如下原则：
(1) 重载运算符含义必须清楚。
  (2) 重载运算符不能有二义性。

运算符重载函数的两种形式

   运算符重载的函数一般地采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。

1. 重载为类的成员函数

这里先举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码：

#include <iostream.h>

class complex
{
public:
    complex() { real=imag=0; }
    complex(double r, double i)
    {
        real = r, imag = i;
    }
    complex operator +(const complex &c);
    complex operator -(const complex &c);
   complex operator *(const complex &c);
  complex operator /(const complex &c);
    friend void print(const complex &c);
private:
double real, imag;
};

inline complex complex::operator +(const complex &c)
{
    return complex(real + c.real, imag + c.imag);
}


inline complex complex::operator -(const complex &c)
{
    return complex(real - c.real, imag - c.imag);
}

inline complex complex::operator *(const complex &c)
{
    return complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
}

inline complex complex::operator /(const complex &c)
{
    return complex((real * c.real + imag + c.imag) / (c.real * c.real + c.imag * c.imag),
            (imag * c.real - real * c.imag) / (c.real * c.real + c.imag * c.imag));

}

void print(const complex &c)

{
    if(c.imag<0)
        cout<<c.real<<c.imag<<'i';
    else
        cout<<c.real<<'+'<<c.imag<<'i';
}

void main()
{
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout<<"/nc1+c2=";
    print(c3);
    c3 = c1 - c2;
    cout<<"/nc1-c2=";
    print(c3);
    c3 = c1 * c2;
    cout<<"/nc1*c2=";
    print(c3);
    c3 = c1 / c2;
    cout<<"/nc1/c2=";
    print(c3);
    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout<<"/n(c1+c2)*(c1-c2)*c2/c1=";
    print(c3);
    cout<<endl;

}

    该程序的运行结果为：

    c1+c2=6+1i
    c1-c2=-2+5i
    c1*c2=14+8i
    c1/c2=0.45+0.8i
    (c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i

在程序中，类 complex 定义了 4 个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下：

< 类名 > operator < 运算符 >(< 参数表 >)
其中， operator 是定义运算符重载函数的关键字。
程序中出现的表达式：

c1+c2

编译程序将给解释为：

c1.operator+(c2)

其中， c1 和 c2 是 complex 类的对象。 operator+() 是运算 + 的重载函数。
该运算符重载函数仅有一个参数 c2 。可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是 this 指针。 this 指针是指向调用该成员函数对象的指针。

2. 重载为友元函数

运算符重载函数还可以为友元函数。当重载友元函数时，将没有隐含的参数 this 指针。这样，对双目运算符，友元函数有 2 个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是： =,(),[] 和 -> 。

重载为友元函数的运算符重载函数的定义格式如下：

friend < 类型说明符 > operator < 运算符 >(< 参数表 >)

    {……}

下面用友元函数代码成员函数，重载编写上述的例子，程序如下：

#include <iostream.h>

class complex

{public:
    complex() { real=imag=0; }
    complex(double r, double i)
    {
        real = r, imag = i;
    }
    friend complex operator +(const complex &c1, const complex &c2);
    friend complex operator -(const complex &c1, const complex &c2);
    friend complex operator *(const complex &c1, const complex &c2);
    friend complex operator /(const complex &c1, const complex &c2);
    friend

        void print(const complex &c);
private:
    double real, imag;
};


complex operator +(const complex &c1, const complex &c2)
{
    return complex(c1.real + c2.real, c1.imag + c2.imag);
}


complex operator -(const complex &c1, const complex &c2)
{
    return complex(c1.real - c2.real, c1.imag - c2.imag);
}

complex operator *(const complex &c1, const complex &c2)
{
    return complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real);
}



complex operator /(const complex &c1, const complex &c2)
{
    return complex((c1.real * c2.real + c1.imag + c2.imag) / (c2.real * c2.real + c2.imag * c2.imag),
            (c1.imag * c2.real - c1.real * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag));
}



void print(const complex &c)
{
    if(c.imag<0)
        cout<<c.real<<c.imag<<'i';
    else
        cout<<c.real<<'+'<<c.imag<<'i';
}



void main()
{
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout<<"/nc1+c2=";
    print(c3);
    c3 = c1 - c2;
    cout<<"/nc1-c2=";
    print(c3);
    c3 = c1 * c2;
    cout<<"/nc1*c2=";
    print(c3);
    c3 = c1 / c2;
    cout<<"/nc1/c2=";
    print(c3);
    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout<<"/n(c1+c2)*(c1-c2)*c2/c1=";
    print(c3);
    cout<<endl;
}


该程序的运行结果与上例相同。前面已讲过，对又目运算符，重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。因此，程序中出现的

c1+c2
编译程序解释为：
operator+(c1, c2)

调用如下函数，进行求值，

complex operator +(const coplex &c1, const complex &c2)

3. 两种重载形式的比较

一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。

其他运算符的重载举例

1). 下标运算符重载

由于 C 语言的数组中并没有保存其大小，因此，不能对数组元素进行存取范围的检查，无法保证给数组动态赋值不会越界。利用 C++ 的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符 [] 。

下面先看看一个例子：

#include <iostream.h>
class CharArray
{
    public:
    CharArray(int l)
    {
        Length = l;
        Buff = new char[Length];
    }
    ~CharArray() { delete Buff; }
    int GetLength() { return Length; }
    char & operator [](int i);
    private:
    int Length;
    char * Buff;
    };



    char & CharArray::operator [](int i)
    {
    static char ch = 0;
    if(i<Length&&i>=0)
        return Buff[i];
    else
    {
        cout<<"/nIndex out of range.";
        return ch;
    }
    }



    void main()
    {
    int cnt;
    CharArray string1(6);
    char * string2 = "string";
    for(cnt=0; cnt<8; cnt++)
        string1[cnt] = string2[cnt];
    cout<<"/n";
    for(cnt=0; cnt<8; cnt++)
        cout<<string1[cnt];
    cout<<"/n";
    cout<<string1.GetLength()<<endl;
    }



    该数组类的优点如下：

(1) 其大小不心是一个常量。
(2) 运行时动态指定大小可以不用运算符 new 和 delete 。
(3) 当使用该类数组作函数参数时，不心分别传递数组变量本身及其大小，因为该对象中已经保存大小。



    在重载下标运算符函数时应该注意：

(1) 该函数只能带一个参数，不可带多个参数。
(2) 不得重载为友元函数，必须是非 static 类的成员函数。


2). 重载增 1 减 1 运算符

增 1 减 1 运算符是单目运算符。它们又有前缀和后缀运算两种。为了区分这两种运算，将后缀运算视为又目运算符。表达式
obj++ 或 obj--
被看作为：
obj++0 或 obj--0

下面举一例子说明重载增 1 减 1 运算符的应用。
#include <iostream.h>

class counter
    {
    public:
    counter() { v=0; }
    counter operator ++();
    counter operator ++(int );
    void print() { cout<<v<<endl; }
    private:
    unsigned v;
    };

    counter counter::operator ++()
    {
    v++;
    return *this;
    }

    counter counter::operator ++(int)
    {
    counter t;
    t.v = v++;
    return t;
    }


    void main()
    {
    counter c;
    for(int i=0; i<8; i++)
        c++;
    c.print();
    for(i=0; i<8; i++)
        ++c;
    c.print();
    }



3). 重载函数调用运算符

    可以将函数调用运算符 () 看成是下标运算 [] 的扩展。函数调用运算符可以带 0 个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。

#include <iostream.h>

class F
    {
    public:
    double operator ()(double x, double y) const;
    };



    double F::operator ()(double x, double y) const
    {
    return (x+5)*y;
    }



    void main()
    {
    F f;
    cout<<f(1.5, 2.2)<<endl;
    }

[/code]

 

虚函数

[code]
虚函数

虚函数是动态联编的基础。虚函数是成员函数，而且是非 static 的成员函数。说明虚函数的方法如下：

virtual < 类型说明符 >< 函数名 >(< 参数表 >)

其中，被关键字 virtual 说明的函数称为虚函数。
如果某类中的一个成员函数被说明为虚函数，这就意味着该成员函数在派生类中可能有不同的实现。当使用这个成员函数操作指针或引用所标识对象时，对该成员函数调用采取动态联编方式，即在运行时进行关联或束定。
动态联编只能通过指针或引用标识对象来操作虚函数。如果采用一般类型的标识对象来操作虚函数，则将采用静态联编方式调用虚函数。

下面给出一个动态联编的例子：

#include <iostream.h>

class Point
    {
    public:
    Point(double i, double j) { x=i; y=j; }
    virtual double Area() const { return 0.0; }
    private:
    double x, y;
    };
    class Rectangle:public Point
    {
    public:
    Rectangle(double i, double j, double k, double l);
    //double Area() const { return w*h; }
    virtual double Area() const { return w*h; }
    private:
    double w, h;
    };

    Rectangle::Rectangle(double i, double j, double k, double l):Point(i, j)
    {
    w=k; h=l;
    }
    void fun(Point &s)
    {
    cout<<s.Area()<<endl;
    }



    void main()
    {
    Rectangle rec(3.0, 5.2, 15.0, 25.0);
    fun(rec);
    }



    通过这个例子可以看到，派生类中对基类的虚函数进行替换时，要求派生类中说明的虚函数与基类中的被替换的虚函数之间满足如下条件：

(1) 与基类的虚函数有相同的参数个数；
(2) 其参数的类型与基类的虚函数的对应参数类型相同；
(3) 其返回值或者与基类虚函数的相同，或者都返回指针或引用，并且派生类虚函数所返回的指针或引用的基类型是基类中被替换的虚函数所返回的指针或引用的基类型的子类型。

满足上述条件的派生类的成员函数，自然是虚函数，可以不必加 virtaul 说明。

总结动态联编的实现需要如下三个条件：

(1) 要有说明的虚函数；
(2) 调用虚函数操作的是指向对象的指针或者对象引用；或者是由成员函数调用虚函数；
  (3) 子类型关系的建立。

以上结果可用以下例子证实。

#include <iostream.h>

class A
    {
    public:
    virtual void act1();
    void act2()
    {
        act1();
        this->act1();
        A::act1();
    }
    };



    void A::act1()
    {
    cout<<"A::act1() called."<<endl;
    }



    class B : public A
    {
    public:
    void act1();
    };



    void B::act1()
    {
    cout<<"B::act1() called."<<endl;
    }



    void main()
    {
    B b;
    b.act2();
    }



    构造函数中调用虚函数时，采用静态联编即构造函数调用的虚函数是自己类中实现的虚函数，如果自己类中没有实现这个虚函数，则调用基类中的虚函数，而不是任何涶生类中实现的虚函数。



    下面通过一个例子说明在构造函数中如何调用虚函数。

#include <iostream.h>

class A
{
    public:
    A() {}
    virtual void f() { cout<<"A::f() called./n"; }
    };


    class B : public A
    {
    public:
    B() { f(); }
    void g() { f(); }
    };



    class C : public B
    {
    public:
    C() {}
    virtual void f() { cout<<"C::f() called./n"; }
    };



    void main()
    {
    C c;
    c.g();
    }



    上面程序的输出结果为：


    A::f() called.
    C::f() called.

关于析构函数中调用虚函数同构造函数一样，即析构函数所调用的虚函数是自身类的或者基类中实现的虚函数。

一般要求基类中说明了虚函数后，派生类说明的虚函数应该与基类中虚函数的参数个数相等，对应参数的类型相同，如果不相同，则将派生类虚函数的参数的类型强制转换为基类中虚函数的参数类型。

                                       

[/code]

 

初始化类中的表数据 [code]
初始化类中的表数据

C++ 中如何初始化类中的表数据？在 C 语言中，我能像下面这样初始化结构数组：
//
struct MYSTRUCT
{
    int x,y,z;
};

MYSTRUCT table[] = {
    { 1,2,3 },
    { 4,5,6 },
    ... // etc
};
//

   但是如果 MYSTRUCT 是个 C++ 类，而不是结构，我编译就会出错。我觉得这是 C++ 的一个不足。

解答：

    这个问题完全取决于你如何看待 C++ 。 C++ 的一个优点之一便是它强制你做正确的事情。例如， C++ 不喜欢创建对象时不调用构造函数。这只就是为什么你不能用原始数据初始化类对象的原因，不管是部分数组还是其它数据。构造函数的目的是保证每一个对象都被正确初始化，不管你是从程序栈，可用内存堆分配空间，还是作为静态数组元素。让原始数据旁路掉构造函数被忌讳的事情。也导致你不能用初始的数据来创建对象静态数组 —— 你必须调用构造函数！


//
class CFooble {
    int x,y,z;
public:
    CFooble(int xx, int yy, int zz)
        : x(xx),y(yy),z(zz) { ... }
    CFooble(int i) { x=y=z=i; }
};



CFooble table[] = {
    CFooble(1,2,3),
    CFooble(4,5,6),
    CFooble(0),    // can use any constructor!
};
//


下面的代码是个可以编译的完整例子。
//
// StaticClassArray — 说明如何初始化在 C++ 对象的静态 C 数组
// 编译方法如下：
//
//    cl fooble.cpp
//
#include <stdio.h>



//////////////////
// 一个典型的类 —— 有三个数据成员 ...
//
class CFooble {
protected:
   int x,y,z;

public:
   // 两个构造函数 ...
   CFooble(int i) { x=y=z=i; }
   CFooble(int xx, int yy, int zz) : x(xx),y(yy),z(zz) { }


   // 一个输出函数
   void print() {
      printf("CFooble at %p: (%d,%d,%d)/n", this, x, y, z);
   }



   // 这个函数检查是否为空 ...
   int IsEmpty() {
      return x==0 && y==0 && z==0;
   }
};



#ifdef NEVER

// 如下这样将不能运行 — 不能 “ 生硬 ” 地进行 C++ 类对象的初始化！

CFooble table[] = {
   { 1,2,3 },
   { 4,5,6 },
   { 0,0,0 }
};

#endif


// 以下是如何初始化一个类数组：
CFooble table[] = {
   CFooble(1,2,3),
   CFooble(4,5,6),
   CFooble(0), // 甚至可以是用不同的构造器！
};



void main()
{
   for (CFooble* pc=table; !pc->IsEmpty(); pc++) {
      pc->print();
   }
}
//

[/code]

 

虚析构函数

[code]
虚析构函数

在析构函数前面加上关键字 virtual 进行说明，称该析构函数为虚析构函数。例如：


    class B
    {
        virtual ~B();
        …
    };


    该类中的析构函数就是一个虚析构函数。

    如果一个基类的析构函数被说明为虚析构函数，则它的派生类中的析构函数也是虚析构函数，不管它是否使用了关键字 virtual 进行说明。

    说明虚析构函数的目的在于在使用 delete 运算符删除一个对象时，能保析构函数被正确地执行。因为设置虚析构函数后，可以采用动态联编方式选择析构函数。

    下面举一个用虚析构函数的例子。

    #include <iostream.h>

    class A
    {
    public:
    virtual ~A() { cout<<"A::~A() Called./n"; }
    };

    class B : public A
    {
    public:
    B(int i) { buf = new char[i]; }
    virtual ~B()
    {
        delete [] buf;
        cout<<"B::~B() Called./n";
}
    private:
    char * buf;
    };

    void fun(A *a)
    {
    delete a;
    }

    void main()
    {
    A *a = new B(15);
    fun(a);
    }



    执行该程序输出如下结果：

    B::~B() Called.
    A::~A() Called.


    如果类 A 中的析构函数不用虚函数，则输出结果如下：
A::~A() Called.
当说明基类的析构函数是虚函数时，调用 fun(a) 函数，执行下述语句：
delete a;
由于执行 delete 语句时自动调用析构函数，采用动态联编，调用它基类的析构函数，所以输出上述结果。
当不说明基类的析构函数为虚函数时， delete 隐含着对析构函数的调用，故产生
A::~A() Called.
的结果。

[/code]