C++100题中的一些问题

//===================================================================================================
#include <iostream>   
using namespace std; 
class Sample
{
 int x,y;
public:
 Sample()
 {
  x=y=0;
 }
 Sample(int a,int b)
 {
  x=a;
  y=b;
 }
 ~Sample()
 {
  if(x==y)
   cout<<"x=y"<<endl;
  else
   cout<<"x!=y"<<endl;
 }
 void disp()
 {
  cout<<"x="<<x<<",y="<<y<<endl;
 }
};
void main()
{
 Sample s1,s2(2,3);
 s1.disp();
 s2.disp();
}
//解： 本题说明了析构函数的调用顺序，这里定义了两个对象，先顺序调用s1和s2对象的构造函数，
//再调用各自的成员函数disp()，最后顺序调用s2和s1的析构函数。所以输出为： x=0,y=0 x=2,y=3 x!=y x=y
//===================================================================================================
#include <iostream>   
using namespace std; 
class Sample
{
public:
 int x,y;
 Sample()
 {
  x=y=0;
 }
 Sample(int a,int b)
 {
  x=a;
  y=b;
 }
 void disp()
 {
  cout<<"x="<<x<<",y="<<y<<endl;
 }
 ~Sample()
 {
  if(x==y)
   cout<<"x=y"<<endl;
  else
   cout<<"x!=y"<<endl;
 }
};
void main()
{
 Sample s1(2,3);
 s1.disp();
 if(s1.x==2)
  exit(0);
}
//解： 本题说明了非正常退出程序时析构函数调用的情况。定义了一个类Sample,
//在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=3),
//然后，调用其成员函数输出数据成员，由于if条件成立，执行exit非正常退出，
//不会隐式调用析构函数，所以输出为： x=2,y=3 注意：如果程序使用exit、abort非正常退出，
//不会隐式调用析构函数，这样造成对象申请资源无法回收，
//从而导致操作系统的资源紧张而使应用程序无法运行。因此在通常情况下，应使用return语句正常退出。
//===================================================================================================
#include <iostream>
using namespace std;
class Sample
{
 int A;
 static int B;
public:
 Sample(int a)
 {
  A=a,B+=a;
 }
 static void func(Sample s);
};
void Sample::func(Sample s)
{
 cout<<"A="<<s.A<<",B="<<B<<endl;
}
int Sample::B=0;
void main()
{
 Sample s1(2),s2(5);
 Sample::func(s1);
 Sample::func(s2);
}
//解： 本题说明了静态成员函数的使用方法。其中的数据成员B是静态数据成员，
//求B之值是在构造函数中进行的。所以输出为： A=2,B=7 A=5,B=7
//注意：静态成员函数与静态数据成员一样，也不是对象成员。静态成员函数的调用不同于普通的成员函数。
//在静态成员函数的实现中，引用类的非静态数据成员是通过对象进行的，如本题中s.A，
//引用类的静态数据成员是直接进行的，如本题中的B。
//===================================================================================================
#include <iostream>
using namespace std;
class Sample
{
public:
 int x;
 int y;
 void disp()
 {
  cout<<"x="<<x<<",y="<<y<<endl;
 }
};
void main()
{
 int Sample::*pc;
 Sample s,*p=&s;
 pc=&Sample::x;
 p->*pc=10;
 pc=&Sample::y;
 p->*pc=20;
 p->disp();
}
//解： 本题说明了类数据成员指针的使用方法。这里通过指向对象的指针来给类数据成员赋值，
//其原理与上题相似。输出为： x=10,y=20
//===================================================================================================
#include <iostream>
using namespace std;
class Sample
{
 int x;
 int y;
public:
 Sample(int a,int b)
 {
  x=a;
  y=b;
 }
 int getx()
 {
  return x;
 }
 int gety()
 {
  return y;
 }
};
void main()
{
 int (Sample::*fp)();
 fp=&Sample::getx;
 Sample s(2,7);
 int v=(s.*fp)();
 fp=&Sample::gety;
 int t=(s.*fp)();
 cout<<"v="<<v<<",t="<<t<<endl;
}
//解： 本题说明了类成员函数指针的使用方法。在main()中定义的fp是一个指向Sample类成员函数的指针。
//执行fp=&Sample::getx后。fp指向成员函数getx(),int v=(s.*fp)()语句等价于int v.getx(),v=x=2;
//执行fp=&Sample::gety之后，fp指向成员函数gety(),int t=(s.*fp)()语句等价于int t=s.gety(),t=x=7。
//所以输出为： v=2,t=7
//===================================================================================================
#include <iostream>
using namespace std;
class base
{
 int n;
public:
 base(int a)
 {
  cout<<"constructing base class"<<endl;
  n=a;
  cout<<"n="<<n<<endl;
 }
 ~base()
 {
  cout<<"destructing base class"<<endl;
 }
};
class subs:public base
{
 base bobj;
 int m;
public:
 subs(int a,int b,int c):base(a),bobj(c)
 {
  cout<<"constructing sub cass"<<endl;
  m=b;
  cout<<"m="<<m<<endl;
 }
 ~subs()
 {
  cout<<"destructing sub class"<<endl;
 }
};
void main()
{
 subs s(1,2,3);
}
//解： 本题说明 派生类中含有对象成员情况下构造函数和析构函数的调用顺序。
//这里base为基类,subs为派生类，subs类的构造函数中含有对象成员。所以输出为：
//constrcuting base class
//n=1
//constructing base class
//n=3
//constructing sub class
//m=2
//destructing sub class
//destructing base class
//destructing base class
//注意：当派生类中含有对象成员时，构造函数的调用顺序如下：
//1)基类的构造函数 2)对象成员的构造函数 3)派生类的构造函数 析构函数的调用顺序与之相反