系统在建立每个对象的过程中将自动调用该类的 使其初.docx
《系统在建立每个对象的过程中将自动调用该类的 使其初.docx》由会员分享，可在线阅读，更多相关《系统在建立每个对象的过程中将自动调用该类的 使其初.docx（14页珍藏版）》请在冰豆网上搜索。
系统在建立每个对象的过程中将自动调用该类的使其初
1、在定义类对象的语句执行时，系统在建立每个对象的过程中将自动调用该类的（）使其初始化。
2、当一个类对象被撤消时将自动调用该类的（）。
3、对基类数据成员的初始化是通过执行派生类构造函数中的（）来实现的。
4、对一个类中的数据成员的初始化可以通过构造函数中的（）实现，也可以通过构造函数中的（）实现。
5、在一个派生类中，对基类成员、类对象成员和非类对象成员的初始化次序是先（），后（），最后为（）。
6、当撤消一个含有基类和类对象成员的派生类对象时，将首先完成（）的析构函数定义体的执行，接着完成（）的析构函数定义体的执行，最后完成（）的析构函数定义体的执行。
7、设px是指向一个类动态对象的指针变量，则执行“deletepx;”语句时，将自动调用该类的（）。
8、当一个类对象离开它的作用域时，系统将自动调用该类的（）。
9、假定一个类对象数组为a[n]，当离开它的作用域时，系统自动调用该类析构函数的次数为（n）。
10、假定AB为一个类，则执行“ABa[10];”语句时，系统自动调用该类构造函数的次数为（）。
11、假定用户没有给一个名为AB的类定义构造函数，则系统为其隐含定义的构造函数为（）。
12、假定用户没有给一个名为AB的类定义析构函数，则系统为其隐含定义的析构函数为（）。
13、若需要把一个函数“voidf（）;”定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句：
（ ）
14、若要把一个类AB定义为一个类CD的友元类，则应在类CD的定义中加入一条语句：
（ ）
15、假定类AB中有一个静态整形成员bb，在类外为它进行定义初始化为0时，所使用的语句为（ ）。
16、假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为（ ）
17、当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为（ ）
18、假定AB这一个类，则该类的拷贝构造函数的声明语句为（ ）。
19、对类对象成员的初始化是通过执行构造函数中的（ ）完成的。
20、对于类中的定义的成员，其隐含访问的权限为（ ），对于结构中定义的成员，其隐含访问权限为（ ）。
21、一个类的友元函数或友元类能够通过成员操作符访问该类的（ ）。
22、假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为：
（ ）。
23、在C＋＋流类库中，根基类为（ ）。
24、在C＋＋流类库中，输入流类和输出流类的名称分别为（ ）和（ ）。
25、若要在程序文件中进行标准输入输出操作，则必须在开始的#include命令中使用（ ）头文件。
26、若要在程序文件中进行文件输入输出操作，则必须在开始的#include命令中使用（ ）头文件。
27、当从字符文件中读取回车和换行两个字符时，被系统看作为一个（ ）。
28、当使用ifstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（）,当使用ofstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（ ）。
29、当需要使用istream流类定义一个流对象并联系一个字符串时，应在文件开始使用#include命令，使之包含（ ）。
1.
#include
usingnamespacestd;
//question1
classA
{
public:
A（）{a=b=0;}
A（intaa,intbb）{
a=aa;
b=bb;
cout<}
private:
inta,b;
};
intmain（）
{
Ax;
Ay（6,3）;
Az（8,10）;
system（"pause"）;
return0;
}
//question2
classA
{
private:
inta;
intb;
public:
A（intaa=0,intbb=0）:
a（aa）,b（bb）{
cout<<"constructor"<}
};
intmain（）
{
Ax;
Ay（2,5）;
Az（y）;
system（"pause"）;
return0;
}
//question3
classA
{
public:
A（intaa=0）
{
a=newint（aa）;
cout<<"constructor!
"<<*a<}
private:
int*a;
};
intmain（）
{
Ax[2];
A*p=newA（5）;
deletep;
system（"pause"）;
return0;
}
//question4
classA
{
public:
A（intaa=0）:
a（aa）{}
~A（）
{
cout<<"deconstructor!
"<}
private:
inta;
};
intmain（）
{
Ax（5）;
A*p=newA（10）;
deletep;
system（"pause"）;
return0;
}
//question5
classA
{
public:
A（intx）
{
a=newint（x）;
cout<<"constructor!
"<<*a<}
~A（）
{
deletea;
cout<<"deconstructor!
"<}
private:
int*a;
};
intmain（）
{
Ax（9）,*p;
p=newA（12）;
deletep;
system（"pause"）;
return0;
}
//question6
classA
{
public:
A（intaa=0）:
a（aa）
{
cout<<"constructorA!
"<}
private:
inta;
};
classB:
publicA
{
public:
B（intaa,intbb）:
A（aa）,b（bb）
{
cout<<"constructorB!
"<}
private:
intb;
};
intmain（）
{
Bx（2,3）;
By（4,5）;
system（"pause"）;
return0;
}
//question7
classA
{
public:
A（intaa=0）:
a（aa）{a=aa;}
~A（）{cout<<"deconstructorA!
"<private:
inta;
};
classB:
publicA
{
public:
B（intaa=0,intbb=0）:
A（aa）{b=bb;）
~B（）{cout<<"deconstructorB!
"<private:
intb;
};
intmain（）
{
Bx（5）;
By（6,7）;
system（"pause"）;
return0;
}
//question8
classA
{
public:
A（intaa,intbb,charch）
{
a=aa;
b=bb;
op=ch;
}
intComp（）
{
switch（op）
{
case'+':
returna+b;
case'-':
returna-b;
case'*':
returna*b;
case'/':
if（b!
=0）
returna/b;
else
exit
（1）;
case'%':
if（b!
=0）
returna%b;
else
exit
（1）;
default:
exit
（1）;
}
}
voidSetA（intaa,intbb,charch）
{
a=aa;
b=bb;
op=ch;
}
private:
inta,b;
charop;
};
intmain（）
{
Ax（3,5,'*'）;
inta=x.Comp（）;
x.SetA（4,9,'+'）;
a+=x.Comp（）;
x.SetA（13,8,'%'）;
a+=x.Comp（）;
cout<<"a="<}
//question9*copy
classA
{
¡¡¡¡public:
¡¡¡¡¡¡A（）{a=b=0;}
¡¡¡¡¡¡A（intaa,intbb）
¡¡¡¡¡¡{a=aa;b=bb;}
¡¡¡¡¡¡Aoperator+（A&x）
¡¡¡¡¡¡{
¡¡¡¡¡¡¡¡¡¡Ar;
¡¡¡¡¡¡¡¡¡¡r.a=a+x.a;
¡¡¡¡¡¡¡¡¡¡r.b=b+x.b;
¡¡¡¡¡¡¡¡¡¡returnr;
¡¡¡¡¡¡}
¡¡¡¡¡¡Aoperator-（A&x）
¡¡¡¡¡¡{
¡¡¡¡¡¡¡¡¡¡Ar;
¡¡¡¡¡¡¡¡¡¡r.a=a-x.a;
¡¡¡¡¡¡¡¡¡¡r.b=b-x.b;
¡¡¡¡¡¡¡¡¡¡returnr;
¡¡¡¡¡¡}
¡¡¡¡¡¡voidOutA（）{cout<¡¡¡¡private:
¡¡¡¡¡¡inta,b;
};
intmain（）
{
¡¡¡¡Ax（6,5）,y（13,3）,z1,z2;
¡¡¡¡z1=x+y;
¡¡¡¡z2=x-y;
¡¡¡¡z1.OutA（）;
¡¡¡¡z2.OutA（）;
system（"pause"）;
return0;
}
//question10*copy
template
classFF
{
public:
FF（TTb1,TTb2,TTb3）{a1=b1;a2=b2;a3=b3;}
TTSum（）{returna1+a2+a3;}
private:
TTa1,a2,a3;
};
intmain（）
{
FFx（8,3,4）,y（5,9,11）;
cout<system（"pause"）;
return0;
}
１、 构造函数
２、 析构函数
３、 继承
４、 函数体初始化表
５、 基类对象成员非对象成员
６、 析构函数
７、 析构函数
８、 析构函数
９、 N
１０、 10
１１、 AB（）{}
１２、 ~AB（）{}
１３、 friendvoidf（）;
１４、 classCD{friendclassAB;};
１５、 intAB:
:
bb=0;
１６、 AB:
:
bb
１７、 n-1
１８、 AB:
:
AB（AB&x）;
１９、 初始化表
２０、 私有公用
２１、 所有数据成员（包括私有成员）
２２、 ABoperator+（AB&x）;
２３、 Ios
２４、 Istreamostream
２５、 Iostream.h
２６、 Fstream.h
２７、 ‘\n’
２８、 ios:
:
inios:
:
out
２９、 stream.h
升级会员 