网络收藏

#include   <iostream.h>  
  #include   <string.h>  
   
  class   b  
  {  
  public:  
  b(char   *s,   double   n)  
  {  
  strcpy(name,   s);  
  b   =   n;  
  cout   <<   "constructor\n";  
  }  
  b(){   cout   <<   "default\n";}  
  ~b(){   cout   <<   "destructor   "   <<   name   <<   endl;   }  
  void   getb(char   *s,   double&   n)  
  {  
  strcpy(s,   name);  
  n   =   b;  
  }  
  private:  
  char   name[80];  
  double   b;  
  };  
   
  void   main()  
  {  
  b   *p;  
  double   n;  
  char   s[80];  
  p   =   new   b[2];  
  p[0]   =   b("ma",   4.8);  
  p[1]   =   b("wang",   3.6);  
  for(int   i=0;   i<2;   i++)  
  {  
  p[i].getb(s,   n);  
  cout   <<   s   <<   ","   <<   n   <<   endl;  
  }  
  delete[]   p;  
  }  
  执行结果：  
  default  
  default  
  constructor  
  destructor   ma                             //为什么这里也调用了？  
  constructor  
  destructor   wang  
  ma,4.8  
  wang,3.6  
  destructor   wang  
  destructor   ma  
   
 

推荐阅读

p[0]=b("ma",4.8);  
   
  这个语句需要创建一个临时对象来执行b::operator   =操作，所以一个constructor.一个destructor   ma(临时对象执行完b::operator=后编译器调用其析构函数)  
   
  下面也是一样的一个constructor   一个destructor

p[0]   =   b("ma",   4.8);  
  创建一个临时对象，然后将其值给p[0]，临时对象使用完毕，自动撤消，所以有构造和析沟

p[0]   =   b("ma",   4.8);  
  这个语句是这样执行的:系统先用构造函数b("ma",4.8)创建一匿名对象并返回该对象,然后调用拷贝初始化构造函数将匿名对象的值按位赋给p[0]，完成后析构匿名对象，所以会多出来两句：  
  constructor  
  destructor   ma    
  p[1]同理  
  你把拷贝初始化构造函数也写出来并测试就明白了，拷贝初始化构造函数有一个默认原型

p[0]   =   b("ma",   4.8);  
  创建一个临时对象，然后将其值给p[0]，临时对象使用完毕，自动撤消，所以有构造和析沟  
 

楼主还没理解？？  
  创建临时对象与是不是对象数组没有关系  
  p[0]   =   b("ma",   4.8);   中的p[0]本身已经是一对象了  
  执行b("ma",4.8)时创建的临时对象并将该对象的值赋给p[0]这个已有对象，临时对象用完当然要析构了，上面语句执行过程中存在两个对象，执行完只有一个对象  
   
  而   b   *b   =   new     b("abcbit",2.3);   是创建一对象并将地址给b，这个对象的析构要你在程序中用delite   b   来做