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)派生类的构造函数 析构函数的调用顺序与之相反