keakon的涂鸦馆

// File Name : polymorphism_test.cpp
// Author : keakon
// Create Date : 2006/5/11
// Last Edited Date : 2006/5/26
// 通过3次测试，演示了如何实现多态性。

#include <iostream>
#include <iterator>
#include <ostream>
#include <string>

using std::cerr;
using std::cout;
using std::string;

//实覆盖
class A1
{
public:
 A1(string const& name) : m_Name(name) {cout << getName() << "A1::A1()\n";}
 ~A1() {cout << getName() << "A1::~A1()\n";}
 void print() const {cout << getName() << "A1::print()\n";}
protected:
 string const& getName() const {return m_Name;}
private:
 string m_Name;
};

class A2 : public A1
{
public:
 A2(string const& name) : A1(name) {cout << getName() << "A2::A2()\n";}
 ~A2() {cout << getName() << "A2::~A2()\n";}
 void print() const {cout << getName() << "A2::print()\n";}
};

//虚覆盖
class B1
{
public:
 B1(string const& name) : m_Name(name) {cout << getName() << "B1::B1()\n";}
 virtual ~B1() {cout << getName() << "B1::~B1()\n";}
 virtual void print() const {cout << getName() << "B1::print()\n";}
protected:
 string const& getName() const {return m_Name;}
private:
 string m_Name;
};

class B2 : public B1
{
public:
 B2(string const& name) : B1(name) {cout << getName() << "B2::B2()\n";}
 virtual ~B2() {cout << getName() << "B2::~B2()\n";}
 virtual void print() const {cout << getName() << "B2::print()\n";}
};

//虚覆盖，并使用实析构函数（这是个错误）
class C1
{
public:
 C1(string const& name) : m_Name(name) {cout << getName() << "C1::C1()\n";}
 ~C1() {cout << getName() << "C1::~C1()\n";}
 virtual void print() const {cout << getName() << "C1::print()\n";}
protected:
 string const& getName() const {return m_Name;}
private:
 string m_Name;
};

class C2 : public C1
{
public:
 C2(string const& name) : C1(name) {cout << getName() << "C2::C2()\n";}
 ~C2() {cout << getName() << "C2::~C2()\n";}
 virtual void print() const {cout << getName() << "C2::print()\n";}
};

//分开各部分的输出
void printLine(unsigned int height = 1, unsigned int length = 20,
        char ch = '-', std::ostream& out = cout)
{
 const string LINE(length, ch);

 for (; height != 0; --height)
 {
  //在out上输出一行ch
  std::copy(LINE.begin(), LINE.end(), std::ostream_iterator<char>(out));
  out << '\n';
 }
}

//测试主体部分
int main()
{
 try
 {
  //实覆盖
  cout << "Real override 1:\n";
  {
   printLine();
   A1 a1("a1.");
   printLine();
   A2 a2("a2.");
   printLine(2);
   
   a1.print();
   printLine();
   a2.print(); //调用的是a2.A2::print()
   printLine();
   static_cast<A1>(a2).print();
   //上句调用A1::A1(A1&)或A1::A1(A1 const&)生成一个临时的A1类的变量
   //然后这个临时变量调用A1::print()
   //在脱离作用域后（该语句结束时）将调用A1::~A1()
   //不调用复制构造函数的转换方式是这样： static_cast<A1&>(a2).print();
   //其余见注释4
   printLine();
   a2.A1::print(); //不同于上句，此处不调用析构函数
   
   printLine(2);
  } //超出作用域，调用析构函数；下面也按照同样的格式使用花括号
  
  printLine(3);

  //使用指针实现实覆盖，可能会产生错误
  cout << "Real override 2:\n";
  {
   printLine();
   A1* pa1 = new A1("pa1->");
   printLine();
   A1* pa2 = new A2("pa2->"); //注意是基类的指针
   printLine();
   A2* pa3 = new A2("pa3->");
   printLine();
   A2 a4("a4.");
   A1* pa4 = &a4; //注意是基类的指针
   A1& ra2 = *pa2; //注意是基类的引用   
   printLine(2);
   
   pa1->print(); //未检查指针，因为出错时new会抛出异常
   printLine();
   pa2->print(); //调用的是pa2->A1::print()
   printLine();
   pa3->print(); //调用的是pa3->A2::print()
   printLine();
   pa4->print(); //调用的是a4.A1::print()，即pa4->A1::print()
   printLine();
   ra2.print();
   printLine(2); //调用的是pa2->A1::print()
   
   delete pa1;
   printLine();
   delete pa2; //错误，(*pa2).A2::~A2()不会被调用
   printLine();
   delete pa3;
   printLine();
   pa1 = NULL;
   pa2 = NULL;
   pa3 = NULL;
   pa4 = NULL; //pa4不是new出来的，不用delete
  }

  printLine(3);
  
  //下面不再重复实覆盖中一些相同的测试
  
  //虚覆盖
  cout << "Virtual override 1:\n";
  {
   printLine();
   B1 b1("b1.");
   printLine();
   B2 b2("b2.");
   printLine();
   
   b1.print();
   printLine();
   b2.print(); //调用的是b2.B2::print()，同实函数一样
   printLine();
  }

  printLine(3);
  
  cout << "Virtual override 2:\n";
  {
   printLine();
   B1* pb1 = new B1("pb1->");
   printLine();
   B1* pb2 = new B2("pb2->"); //注意是基类的指针
   printLine();
   B1& rb2 = *pb2; //注意是基类的引用
   printLine();
   
   pb1->print();
   printLine();
   pb2->print(); //调用的是pb2->B2::print()
   printLine();
   rb2.print(); //调用的是pb2->B2::print()
   printLine();
   
   delete pb1;
   printLine();
   delete pb2;
   pb1 = NULL;
   pb2 = NULL;
  }

  printLine(3);
  
  //虚覆盖，并使用实析构函数（这是个错误）
  cout << "Virtual override 1, using real destruction:\n";
  {
   printLine();
   C1 c1("c1.");
   printLine();
   C2 c2("c2.");
   printLine(2);
   
   c1.print();
   printLine();
   c2.print();
   printLine(2);
  }
  
  printLine(3);

  cout << "Virtual override 2, using real destruction:\n";
  {
   printLine();
   C1* pc1 = new C1("pc1->");
   printLine();
   C1* pc2 = new C2("pc2->"); //注意是基类指针
   printLine(2);
   
   pc1->print();
   printLine();
   pc2->print(); //pc2->C2::~C2()不会被调用
   printLine(2);
   
   delete pc1;
   printLine();
   delete pc2;
   cout << std::endl;
   pc1 = NULL;
   pc2 = NULL;
  }
  
  return 0;
 }

 catch (std::bad_alloc&)
 //如果内存不够，new抛出std::bad_alloc
 //似乎在VC++下永远不会抛出该异常，但也不会出错；在g++等编译器中则会抛出该异常
 //关于VC不抛出std::bad_alloc的原因是，标准C++是可以设置set_new_handle的，只在它为NULL或显式抛出时才抛出 
 //而VC++6必须为NULL（assert了），但却不抛出＝。＝
 {
  cerr << "\n内存不足!\n";
  return 1;
 }

 catch (...)
 {
  cerr << "\n发现未知异常，也许你人品有问题。";
  return 2;
 }
}
//注：其实格式完全不必这样写，很多都无需测试；但为了便于对照，我还是这样写了。