C++类与对象习题及解答
类与对象习题
一.基本概念与基础知识自测题
4.1 填空题
5.1.1 引入类定义的关键字是(1)。类的成员函数通常指定为(2),类的
数据成员通常指定为(3)。指定为(4)的类成员可以在类对象所在域中的任何位置访问它们。通常用类的(5)成员表示类的属性,用类的(6)成员表示类的操作。
答案:
(1)class
(2)公有的public
(3)私有的private
(4)公有的public
(5)数据
(6)函数
4.1.2 类的访问限定符包括(1)、(2)和(3)。私有数据通常由
(4)函数来访问(读和写)。这些函数统称为(5)。
答案:
(1)public(公有的)
(2)private(私有的)
(3)protected(保护的)
(4)公有的成员函数
(5)类的接口
4.1.3 通常在逻辑上,同一类的每个对象都有(1)代码区,用以存储成员函数。而
在物理上通常只有(2)代码区。只有在(3)定义,并(4)的函数和加了关键字(5)的函数例外。
答案:
(1)独立的
(2)共用的
(3)在类说明中
(4)不包括循环等复杂结构
(5)inline
4.1.4 C++中支持三种域:(1)、(2)、(3)。函数域被包括在
(4)中,全局域被包括在(5)中。using指示符以关键字using开头,后面是关键字(6),最后是(7)。这样表示以后在该名字空间中所有成员都(8)。如不使用using指示符则在使用时要加::,称为(9)运算符。
答案:
(1)局部域(local scope)
(2)名字空间域(namespace scope)
(3)类域(class scope)
(4)局部域
(5)名字空间域
(6)namespace
(7)名字空间名
(8)可以直接被使用
(9)域
4.1.5 引用通常用作函数的(1)和(2)。对数组只能引用(3)不能引用(4)。答案:
(1)参数
(2)返回值
(3)数组元素
(4)数组名本身
4.1.6 构造函数的任务是(1)。构造函数无(2)。类中可以有(3)个
构造函数,它们由(4)区分。如果类说明中没有给出构造函数,则C++编译器会(5)。拷贝构造函数的参数是(6),当程序没有给出复制构造函数时,系统会自动提供(7)支持,这样的复制构造函数中每个类成员(8)。答案:
(1)初始化数据成员
(2)函数返回类型说明
(3)多
(4)不同的参数表
(5)自动给出一个默认的构造函数
(6)同一类对象的引用
(7)默认的的复制构造函,称为默认的按成员语义支持。
(8)被依次复制
4.1.7 一个类有(1)个析构函数。(2)时,系统会自动调用析构函数。答案:
(1)一
(2)对象注销时
4.1.8 运算符重载时,其函数名由(1)构成。成员函数重载双目运算符时,左操作
数是(2),右操作数是(3)。
答案:
(1)关键字operator和该运算符
(2)对象
(3)该函数的参数
4.1.9面向过程的程序设计中程序模型描述为(1),面向对象程序设计的程序模型可描
述为(2)。
答案:
(1)“程序=算法+数据结构”。其数据与数据处理是分离的。
(2)程序=(对象+对象+……+对象)+消息;对象=(算法+数据结构)。面向对象设计将数据和对数据的操作方法放在一起,形成一个相对独立的整体——对象(Object),并通过简单的接口与外部联系。对象之间通过消息(Message)进行通讯。
4.2 简答题
4.2.1 简单解释什么是面向对象程序设计的封装性。
答:对象是一个封装体,在其中封装了该对象所具有的属性和操作。对象作为独立的基本单元,实现了将数据和数据处理相结合的思想。此外,封装特性还体现在可以限制对象中数据和操作的访问权限,从而将属性“隐藏”在对象内部,对外只呈现一定的外部特性和功能。
封装性增加了对象的独立性,C++通过建立数据类型——类,来支持封装和数据隐藏。一个定义完好的类一旦建立,就可看成完全的封装体,作为一个整体单元使用,用户不需要知道这个类是如何工作的,而只需要知道如何使用就行。另一方面,封装增加了数据的可靠性,保护类中的数据不被类以外的程序随意使用。这两个优点十分有利于程序的调试和维护。
4.2.2 C++编译器怎样对标识符进行解析?
答:编译器对标识符的解析分两步,第一步查找在声明中用到的标识符,特别是函数成员声明中用到的参数类型,第二步是函数成员体内的标识符。
4.2.3 为什么说类与对象的概念是客观世界的反映?
答:客观世界的事物都具有某些属性和行为(或操作),具有相同属性和行为的事物可以归属于一类,用分类的方法可以提高认识事物的效率。C++中定义的类则是通过抽象的方法将某一类事物共有的静态特征(属性)和动态特征(行为)概括出来并加以描述,而对象是类的具体实现,所以说类与对象的概念是客观世界的反映。
4.2.4 什么叫类域?为什么说类域是抽象的?
答:类域是类体所包括的范围。每个类定义都引入了一个独立的类域,在类域中说明的标识符仅在该类的类域中有效。由于类只是一个说明,看上去有数据,有函数,有类型定义,但是它并非实体,不分配内存,当然也不能运行。所以说类域是抽象的。
4.2.5 引用作为函数参数时为什么能实现两个实参之间的数据交换?为什么对应实参不能为引用?为什么返回值为引用的函数可以作为左值?
答:引用变量是其关联变量的别名,二者在内存中占据同一个存储单元。在一个以引用作为参数的函数中,交换两个参数的值,实际上就是交换两个实参的值。如果函数的参数是引用,调用时需要取得实参的地址,而实参如果已经是一个地址,再进行引用将产生错误,故对应实参不能为引用。
函数返回引用实际是指明(返回)了相应的关联变量,所以声明返回值为引用的函数实际上是将关联变量作为左值参与运算。
4.2.6 什么是缺省的构造函数?缺省的构造函数最多可以有多少个?
答:如果在类定义中不显式地定义构造函数,C++编译器会自动产生一个缺省的构造函数,不过该函数不做具体的初始化工作。只要构造函数是无参的或者只要各参数均有缺省值的,C++编译器都认为是缺省的构造函数。缺省的构造函数只能有一个。
4.2.7 拷贝构造函数用于哪三个方面?
答:
(1)用类的一个对象去初始化该类的另一个对象时使用。
(2)当函数的形参是类的对象,调用函数时,进行形参与实参结合时使用。
(3)当函数的返回值是类对象,函数执行结束返回调用者时使用。
4.2.8 写出含有对象成员的类的构造函数的格式,并做简单说明。
答:C++中对含对象成员的类对象的构造函数有固定的格式:
类名::构造函数名(参数总表):对象成员1(参数名表1),对象成员2(参数名表2),……对象成员n(参数名表n){……}
冒号后用逗号隔开的是要初始化的对象成员,附在后面的参数名表1,…,参数名表n依次为调用相应对象成员所属的构造函数时的实参表。这些表中的参数通常来自冒号前的参数总表,但没有类型名。
4.2.9 所有类对象未重载的赋值运算符“=”是怎样工作的?为什么它可以进行连续赋值?答:对所有的类对象,未重载的赋值运算符“ =”称作缺省的按成员拷贝赋值操作符,同类对象之间可以用“=”直接拷贝。因为缺省的赋值操作返回一个对象的引用,所以它可以进行连续赋值。
4.2.10 为什么在友元函数的函数体内访问对象成员时,必须用对象名加运算符“.”再加对象成员名?
答:友元函数不是类的成员函数,在函数体中访问对象的成员,必须用对象名加运算符“.”加对象成员名。这一点和一般函数一样。
4.2.11 重载复数运算符+时,采用下面友元函数声明:
friend Complex operator+(Complex &c1,Complex &c2);
为什么不能用于“实数+复数”?怎样改进才能适用?为什么?
答:使用引用类型变量作为运算符重载函数的参数,身为左值的实数类型实参不能被转换为复数,编译时无法通过。添加const说明,使实数到复数的转换隐式地在一份拷贝上进行,则可以实现“实数+复数”运算。修改后的说明为:
friend Complex operator+(const Complex &c1, const Complex &c2);
4.2.12 类的静态数据成员与函数中的静态成员有何异同?
答:类的静态成员为其所有对象共享,不管有多少对象,静态成员只有一份存于公用内存中,为该类所有对象公用。函数中的静态变量也位于公用内存中,不随函数调用而重新分配,所以总是保留上次进入并执行该函数后留下的信息。
4.2.13 C++中结构、联合与类三者间有何异同?
答:在C++中结构(structure)与类几乎是完全一样的类型,差别仅仅在于缺省情况下结构的成员为公有的。联合(union)是C++的导出数据类型,在语法与功能上类似于结构,二者的区别是:结构变量的各成员同时被分配了各自独立的内存区,而联合变量的各个成员的存储开始地址都相同,所以在任一时刻联合变量只能存储一个成员。
4.2.14 对象的第一特征是封装,那么由对象组成的面向对象的程序怎样建立各对象之间的有效联系?面向对象程序的组织与面向过程有什么不同?
答:因为对象的操作主要用来响应外来消息并为其他对象提供服务,所以面向对象的程序利用消息传递机制来建立各对象之间的有效联系,协调各对象的运行。一个对象可以向其他对象发送消息以请求服务,也可以响应其他对象传来的消息,完成自身固有的某些操作,从而服务于其他对象。
面向过程的程序是模块化的,模块的组织具有分层结构特点,层与层之间是调用关系。面向对象程序是由一个个封装的对象组成,而对象是由紧密结合在一起的算法和数据结构组成。对象之间是相互请求和相互协作的关系。
4.2.15 简叙Windows下应用程序的运行方式。
答:Windows系统支持多个应用程序同时执行,在界面形式上,它支持多个窗口同时活动。它的运行机制是“消息传递和事件驱动(message based and event driven)”。
Windows系统使用事件驱动的编程模式。所谓事件的含义非常广泛。输入设备的动作,如敲打键盘、按鼠标等会产生一系列的事件(注意不是一个事件)。操作系统所作的一举一动也被当作某种类型的事件,应用程序也会产生各种事件。事件用来标识发生的某件事情。
Windows系统对于应用程序环境中发生的每一个事件都会以对应的某种消息的形式标识,并放入相应的Windows建立的消息队列中,然后由对应的应用程序或窗口函数去处理。窗口函数处理是分层的,前面处理不了的送到后面,最后处理不了剩下的全由缺省的窗口函数处理。
4.2.16 类的成员函数在什么情况下应该定义为私有的?这样做的目的是什么?
答:除接口函数和创建本类对象的构造函数和撤消该对象的析构函数外。其余成员函数应该定义为私有的,这是开发类时故意对外隐蔽起来的操作,而这些往往是最复杂最关键的部分。类中故意的隐藏也为以后的升级扩展留下了余地,只要接口不变,内部再变,也不必修改原来的程序,就象MFC(微软基础类)升级后,由MFC底层类所编的程序完全不必修改,自动升级。
二.编程与综合练习题
4.3 构造一个日期时间类(Timedate),数据成员包括年、月、日和时、分、秒,函数成员
包括设置日期时间和输出时间,其中年、月请用枚举类型,并完成测试。(包括用成员函数和用普通函数)
解:本题要求仅是定义类的练习,并非实用的提供日期时间的程序。实用的日期时间程序见附录二的日期时间函数。
#include
#include
using namespace std;
enum YR{Y2000,Y2001,Y2002,Y2003,Y2004,Y2005};//
enum MT{Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec};
class Timedate{
private:
YR year;
MT month;
int date;
int hh;
int mm;
int ss;
public:
Timedate(){year=Y2000;month=Jan;date=1;hh=0;mm=0;ss=0;}
Timedate(YR a,MT b,int c){
year=a;
month=b;
date=c;
hh=12;mm=30;ss=0;
}
void getdate(YR &,MT &,int &);//使用引用一次取得3个数值void gettime(int &,int &,int &);
void putdate(YR ,MT ,int );
void puttime(int ,int ,int );
void list();
};
void Timedate::getdate(YR &y,MT &m,int &d){
y=year;
m=month;
d=date;
}
void Timedate::gettime(int &a,int &b,int &c){
a=hh;
b=mm;
c=ss;
}
void Timedate::putdate(YR a,MT b,int c){
year=a;
month=b;
date=c;
}
void Timedate::puttime(int a,int b,int c){
hh=a;
mm=b;
ss=c;
}
void Timedate::list(){//成员函数,直接访问私有的数据成员cout<<"year/month/date :";
switch(year){
case Y2000:cout<<"2000";break;
case Y2001:cout<<"2001";break;
case Y2002:cout<<"2002";break;
case Y2003:cout<<"2003";break;
case Y2004:cout<<"2004";break;
case Y2005:cout<<"2005";break;
}
switch(month){
case Jan:cout<<'/'<<"Jan";break;
case Feb:cout<<'/'<<"Feb";break;
case Mar:cout<<'/'<<"Mar";break;
case Apr:cout<<'/'<<"Apr";break;
case May:cout<<'/'<<"May";break;
case Jun:cout<<'/'<<"Jun";break;
case Jul:cout<<'/'<<"Jul";break;
case Aug:cout<<'/'<<"Aug";break;
case Sep:cout<<'/'<<"Sep";break;
case Oct:cout<<'/'<<"Oct";break;
case Nov:cout<<'/'<<"Nov";break;
case Dec:cout<<'/'<<"Dec";break;
}
cout<<'/'< cout<<"hour:minite:second :"; cout< } int main(int argc, char* argv[]){ Timedate A(Y2004,Mar,3),B; A.list(); B.list(); B.putdate(Y2005,Oct,18); B.puttime(17,30,00); B.list(); return 0; } 4.4 设计并测试一个矩形类(Rectangle),属性为矩形的左下与右上角的坐标,矩形水平放置。操作为计算矩形周长与面积。测试包括用成员函数和普通函数。 解:这里的矩形的4边分别与x轴y轴平行,为最简单的情况。注意参数有缺省值的函数的声明和定义格式。 #include #include using namespace std; class Rectangle { double left, top ; double right, bottom; public: Rectangle(double l=0, double t=0, double r=0, double b=0); ~ Rectangle(){}; //析构函数,在此函数体为空 void Assign(double l,double t,double r,double b); double getLeft(){ return left;} // 以下四个函数皆为内联成员函数 double getRight(){ return right;} double getTop(){return top;} double getBottom(){return bottom;} void Show(); double Area(); double Perimeter(); }; // 构造函数,带缺省参数,缺省值为全0,在声明中指定 Rectangle::Rectangle(double l , double t, double r, double b) { left = l; top = t; right = r; bottom = b; } void Rectangle::Assign(double l, double t, double r, double b){//赋值 left = l; top = t; right = r; bottom = b; } void Rectangle::Show(){//成员函数直接使用私有的数据成员 cout<<"left-top point is ("< cout<<"right-bottom point is ("< } double Rectangle::Area(){ return fabs((right-left)*(bottom-top)); } double Rectangle::Perimeter(){ return 2*(fabs(right-left)+fabs(bottom-top)); } int main(){ Rectangle rect; rect.Show(); rect.Assign(100,200,300,400); rect.Show(); Rectangle rect1(0,0,200,200); rect1.Show(); Rectangle rect2(rect1); rect2.Show(); cout<<"面积"< return 0; } 4.5 定义一个圆类(Circle),属性为半径(radius)、圆周长和面积,操作为输入半径并计算周长、面积,输出半径、周长和面积。要求定义构造函数(以半径为参数,缺省值为0,周长和面积在构造函数中生成)和拷贝构造函数。 解:通常所有数据成员都在构造函数中赋初值。拷贝构造函数以本类的引用为参数。 #include #include using namespace std; class Circle{ double r,Area,Circumference; public: Circle(double a=0); Circle(Circle &); void SetR(double R); double GetR(){return r;} double GetAreaCircle(){return Area;} double GetCircumference(){return Circumference;} }; Circle::Circle(double a){ r=a; Area=r*r*3.14159265; Circumference=2*r*3.14159265; } Circle::Circle(Circle & cl){ r=cl.r; Area=cl.Area; Circumference=cl.Circumference; } void Circle::SetR(double R){ r=R; Area=r*r*3.14159265; Circumference=2*r*3.14159265; } int main(){ Circle cl1(2),cl2,cl3=cl1; cout<<"圆半径:"< <<'\t'<<"圆面积:"< cl2.SetR(4); cout<<"圆半径:"< <<'\t'<<"圆面积:"< return 0; } 4.6 设计一个学校在册人员类(Person)。数据成员包括:身份证号(IdPerson),姓名(Name),性别(Sex),生日(Birthday)和家庭住址(HomeAddress)。成员函数包括人员信息的录入和显示。还包括构造函数与拷贝构造函数。设计一个合适的初始值。 解:本题为指出构造函数等的调用,加了一些提示语句。 #include #include using namespace std; enum Tsex{mid,man,woman}; class Person{ char IdPerson[19]; //身份证号,18位数字 char Name[20]; //姓名 Tsex Sex; //性别 int Birthday; //生日,格式1986年8月18日写作19860818 char HomeAddress[50]; //家庭地址 public: Person(char *,char *,Tsex,int,char *); Person(Person &); Person(); ~Person(); void PrintPersonInfo(); void inputPerson(); //其他接口函数 }; Person::Person(char *id,char *name,Tsex sex,int birthday,char *homeadd){ cout<<"构造Person"< strcpy(IdPerson,id); strcpy(Name,name); Sex=sex; Birthday=birthday; strcpy(HomeAddress,homeadd); } Person::Person(){ cout<<"缺省构造Person"< IdPerson[0]='\0';Name[0]='\0';Sex=mid; Birthday=0;HomeAddress[0]='\0'; } Person::Person(Person & Ps){ cout<<"拷贝构造Person"< strcpy(IdPerson,Ps.IdPerson); strcpy(Name,https://www.360docs.net/doc/cf15843039.html,); Sex=Ps.Sex; Birthday=Ps.Birthday; strcpy(HomeAddress,Ps.HomeAddress); } Person::~Person(){ cout<<"析构Person"< } void Person::inputPerson(){ char ch; cout<<"请输入身份证号,18位数字:"< cin.getline(IdPerson,19); cout<<"请输入姓名:"< cin.getline(Name,20); cout<<"请输入性别m或w:"< cin>>ch; if(ch=='m') Sex=man; else Sex=woman; cout<<"请输入生日,格式1986年8月18日写作19860818:"< cin>>Birthday; cin.get(); //吸收回车符,否则地址输不进去 cout<<"请输入地址:"< cin.getline(HomeAddress,50); } void Person::PrintPersonInfo(){ int i; cout<<"身份证号:"< if(Sex==man)cout<<"男"<<'\n'; else if(Sex==woman)cout<<"女"<<'\n'; else cout<<" "<<'\n'; cout<<"出生年月日:"; i=Birthday; cout< i=i%10000; cout< } int main(){ Person Ps1("320102*********","朱海鹏",man,19811226,"南京市黄浦路1号"), Ps2(Ps1),Ps3; Ps1.PrintPersonInfo(); Ps2.PrintPersonInfo(); Ps3.inputPerson(); Ps3.PrintPersonInfo(); return 0; } 4.7 对上面4道题中的类对象的数据,由友元函数来进行访问。并对比友元函数、成员函数和普通函数使用上的不同。 解:友元函数可直接访问私有成员。友元函数在类中声明时不问访问权限。仅以5.4题为例。#include #include using namespace std; class Rectangle { double left, top ; double right, bottom; public: Rectangle(double l=0, double t=0, double r=0, double b=0); ~ Rectangle(){}; //析构函数,在此函数体为空 void Assign(double l,double t,double r,double b); double getLeft(){ return left;} // 以下四个函数皆为内联成员函数 double getRight(){ return right;} double getTop(){return top;} double getBottom(){return bottom;} void Show(); friend void showprint(Rectangle); double Area(); double Perimeter(); }; // 构造函数,带缺省参数,缺省值为全0,在声明中指定 Rectangle::Rectangle(double l , double t, double r, double b) { left = l; top = t; right = r; bottom = b; } void Rectangle::Assign(double l, double t, double r, double b){//赋值 left = l; top = t; right = r; bottom = b; } double Rectangle::Area(){ return fabs((right-left)*(top-bottom)); } double Rectangle::Perimeter(){ return 2*(fabs(right-left)+fabs(top-bottom)); } void Rectangle::Show(){//成员函数 cout<<"left-top point is ("< cout<<"right-bottom point is ("< } void showprint(Rectangle rt){//友元函数,要加类名,但直接调用私有数据成员cout<<"left-top point is ("< cout<<"right-bottom point is ("< } void print(Rectangle rt){//普通函数,要用接口函数间接调用私有数据成员cout<<"left-top point is ("< cout<<"right-bottom point is ("< int main(){ Rectangle rect; rect.Show(); rect.Assign(100,400,300,200); rect.Show(); Rectangle rect1(0,200,200,0); rect1.Show(); Rectangle rect2(rect1); rect2.Show(); print(rect); showprint(rect); cout<<"面积"< return 0; } 4.8 为复数类(Complex)增加重载的运算符-、-=、*=和/=。设++为实部和虚部各自增一, 亦请重载前置与后置++运算符。分别使用成员函数和友元函数各做一遍。并测试。解:注意后++,返回的是原值,但实部和虚部已各自增一,所以要先保留原值,再++。这里是使用成员函数。 #include using namespace std; class complex{ private: double real; //实部 double imag; //虚部 public: complex(double r = 0.0 ,double i = 0.0 ); //构造函数 void print(); //显示复数 complex operator+(complex c); //重载复数"+" complex operator-(complex c); //重载复数"-" complex operator*(complex c); //重载复数"*" complex operator/(complex c); //重载复数"/" complex operator +=(complex c); //重载复数"+=" complex operator -=(complex c); //重载复数"-=" complex operator *=(complex c); //重载复数"*=" complex operator /=(complex c); //重载复数"/=" complex operator ++(); //重载复数前缀"++" complex operator ++(int); //重载复数后缀"++" }; complex::complex(double r,double i){ real = r; imag = i; } complex complex::operator +(complex c){ //重载复数"+" complex temp; temp.real=real+c.real; temp.imag=imag+c.imag; return temp; //返回局部变量,函数声明不可为引用,这时返回了局部变量的地址 } complex complex::operator -(complex c){ //重载复数"-" temp.real=real-c.real; temp.imag=imag-c.imag; return temp; } complex complex::operator *(complex c){ //重载复数"*" complex temp; temp.real=real*c.real-imag*c.imag; temp.imag=real*c.imag+imag*c.real; return temp; } complex complex::operator /(complex c){ //重载复数"/" complex temp; double d; d=c.real*c.real+c.imag*c.imag; temp.real=(real*c.real+imag*c.imag)/d; temp.imag=(c.real*imag-real*c.imag)/d; return temp; } complex complex::operator +=(complex c){ //重载复数"+=" complex temp; temp.real=real+c.real; temp.imag=imag+c.imag; real=temp.real; imag=temp.imag; return temp; } complex complex::operator -=(complex c){ //重载复数"-=" complex temp; temp.real=real-c.real; temp.imag=imag-c.imag; real=temp.real; imag=temp.imag; return temp; } complex complex::operator *=(complex c){ //重载复数"*=" complex temp; temp.real=real*c.real-imag*c.imag; temp.imag=real*c.imag+imag*c.real; real=temp.real; imag=temp.imag; return temp; } complex complex::operator /=(complex c){ //重载复数"/=" double d; d=c.real*c.real+c.imag*c.imag; temp.real=(real*c.real+imag*c.imag)/d; temp.imag=(c.real*imag-real*c.imag)/d; real=temp.real; imag=temp.imag; return temp; } complex complex::operator ++(){ //重载复数前缀"++" complex temp; temp.real=++real; temp.imag=++imag; return temp; } complex complex::operator ++(int){ //重载复数后缀"++" complex temp(real,imag); real++; imag++; return temp; } void complex::print(){ //显示复数cout << real; if(imag>=0) cout<<'+'; cout< } int main(){ complex A(30,40),B(15,30),C,D; //定义4个复数对象 cout<<"A为:"; A.print(); C=A.operator++(1);//即C=A++完整的表达式 cout<<"C=A++后,C为:"; C.print(); cout<<"A为:"; A.print(); C=A.operator++();//即++A cout<<"C=++A后,C为:"; C.print(); cout<<"A为:"; A.print(); C=A*B; cout<<"C=A*B后,C为:"; C.print(); A*=B; cout<<"A*=B后,A为:"; A.print(); C=A/B; cout<<"C=A/B后,C为:"; C.print(); A/=B; cout<<"A/=B后,A为: "; A.print(); cout<<"B为:"; B.print(); D=A+B+C; cout<<"D=A+B+C后,D为:"; D.print(); A+=B+=C; cout<<"A+=B+=C后,A为:"; A.print(); cout<<"B为:"; B.print(); D=A-B-C; cout<<"D=A-B-C后,D为:"; D.print(); A-=B+=C; cout<<"A-=B+=C后,A为:"; A.print(); cout<<"B为:"; B.print(); A=B; cout<<"A=B后,A为:"; A.print(); D=A*B*C; cout<<"D=A*B*C后,D为:"; D.print(); D=D/B/C; cout<<"D=D/B/C后,D为:"; D.print(); A*=B*=C; cout<<"A*=B*=C后,A为:"; A.print(); A/=B/=C/=C; cout<<"A/=B/=C/=C后,A为:"; A.print(); return 0; } 解2: #include class complex{ private: double real; //实部 double imag; //虚部 public: complex(double r = 0.0 ,double i = 0.0 ); //构造函数 void print(); //显示复数 friend complex operator+(const complex &,const complex &); //重载复数"+" friend complex operator-(const complex &,const complex &); //重载复数"-" friend complex operator*(const complex &,const complex &); //重载复数"*" friend complex operator/(const complex &,const complex &); //重载复数"/" friend complex &operator+=(complex &,const complex &); //重载复数"+=" friend complex &operator-=(complex &,const complex &); //重载复数"-=" friend complex &operator*=(complex &,const complex &); //重载复数"*=" friend complex &operator/=(complex &,const complex &); //重载复数"/=" friend complex operator++(complex &); //重载复数前缀"++" friend complex operator++(complex &,int); //重载复数后缀"++" }; complex::complex(double r,double i){ real=r; imag=i; } complex operator +(const complex &c1,const complex &c2){ //重载复数"+" complex temp; temp.real=c1.real+c2.real; temp.imag=c1.imag+c2.imag; return temp; //返回局部变量,函数声明不可为引用,这时返回了局部变量的地址} complex operator -(const complex &c1,const complex &c2){ //重载复数"-" complex temp; temp.real=c1.real-c2.real; temp.imag=c1.imag-c2.imag; return temp; } complex operator *(const complex &c1,const complex &c2){ //重载复数"*" complex temp; temp.real=c1.real*c2.real-c1.imag*c2.imag; temp.imag=c1.real*c2.imag+c1.imag*c2.real; return temp; } complex operator /(const complex &c1,const complex &c2){ //重载复数"/" complex temp; double d; d=(c2.real*c2.real+c2.imag*c2.imag); temp.real=(c1.real*c2.real+c1.imag*c2.imag)/d; temp.imag=(c2.real*c1.imag-c1.real*c2.imag)/d; return temp; } complex &operator +=(complex &c1,const complex &c2){ //重载复数"+=" c1.real=c1.real+c2.real; c1.imag=c1.imag+c2.imag; return c1; //返回由引用参数传递过来的变量,函数声明可为引用 } complex &operator -=(complex &c1,const complex &c2){ //重载复数"-=" c1.real=c1.real-c2.real; c1.imag=c1.imag-c2.imag; return c1; } complex &operator *=(complex &c1,const complex &c2){ //重载复数"*=" complex temp; temp.real=c1.real*c2.real-c1.imag*c2.imag; temp.imag=c1.real*c2.imag+c1.imag*c2.real; c1=temp; return c1; } complex &operator /=(complex &c1,const complex &c2){ //重载复数"/=" complex temp; double d; d=(c2.real*c2.real+c2.imag*c2.imag); temp.real=(c1.real*c2.real+c1.imag*c2.imag)/d; temp.imag=(c2.real*c1.imag-c1.real*c2.imag)/d; c1=temp; return c1; } complex operator ++(complex & c){ //重载复数前缀"++" ++c.real; ++c.imag; return c; } complex operator ++(complex & c,int){ //重载复数后缀"++" complex temp(c.real,c.imag); c.real++; c.imag++; return temp; } void complex::print(){ //显示复数 cout< if(imag>=0) cout<<'+'; cout< } int main(){ complex A(30,40),B(15,30),C,D; //定义4个复数对象 cout<<"A为:"; A.print(); C=A.operator++(1);//即C=A++完整的表达式 cout<<"C=A++后,C为:"; C.print(); cout<<"A为:"; A.print(); C=A.operator++();//即++A cout<<"C=++A后,C为:"; C.print(); cout<<"A为:"; A.print(); C=A*B; cout<<"C=A*B后,C为:"; C.print(); A*=B; cout<<"A*=B后,A为:"; A.print(); C=A/B; cout<<"C=A/B后,C为:"; C.print(); A/=B; cout<<"A/=B后,A为: "; A.print(); cout<<"B为:"; B.print(); D=A+B+C; cout<<"D=A+B+C后,D为:"; D.print(); A+=B+=C; cout<<"A+=B+=C后,A为:"; A.print(); cout<<"B为:"; B.print(); D=A-B-C; cout<<"D=A-B-C后,D为:"; D.print(); A-=B+=C; cout<<"A-=B+=C后,A为:"; A.print(); cout<<"B为:"; B.print(); A=B; cout<<"A=B后,A为:"; A.print(); D=A*B*C; cout<<"D=A*B*C后,D为:"; D.print(); D=D/B/C; cout<<"D=D/B/C后,D为:"; D.print(); A*=B*=C; cout<<"A*=B*=C后,A为:"; A.print(); A/=B/=C/=C; cout<<"A/=B/=C/=C后,A为:"; A.print(); return 0; } 4.9 分析下面程序的执行结果: int main(){ union{ char word[8]; shor int ksi[4]; }x,*s; s=&x; s->ksi[0]=0x6f6d; s->ksi[1]=0x6e72; s->ksi[2]=0x6e69; s->ksi[3]=0x0067; cout< return 0; } 仿照上述程序,编写一个输出字符串为“computer!”的程序。 输出:morning #include using namespace std; union chint{ char word[10]; short int ksi[5]; }; int main(){ //数字转换为字符串 chint x,*s; s = &x; s->ksi[0] = 0x6f63; s->ksi[1] = 0x706d; s->ksi[2] = 0x7475; s->ksi[3] = 0x7265; s->ksi[4] = 0x0021; cout< getchar(); return 0; } 4.10 内置数据类型可以进行类型强制转换,类也可以进行同样的转换,这是通过定义类型 转换函数实现的。它只能是类的成员函数,不能是友元函数。格式为: 类名::operator 转换后的数据类型( ) {…} 如:operator float()是转换为浮点数的成员函数。使用时的格式为: float(对象名); 或(float) 对象名; 定义人民币类,数据成员包括:圆、角、分,均为整型。类型转换函数将人民币类强制转换为浮点数,以圆为单位。并编程进行检验。 解:本题的解答未考虑角、分最多为9。类型强制转换的两种格式编程时毋需考虑,自动实现。 #include using namespace std; class IntRMB{ //人民币类 private: int IYuan; int Jiao; int Fen; public: IntRMB(int y=0,int j=0,int f=0); //构造函数 C语言题库及答案 姓名成绩 温馨提示:同学们,经过培训学习,你一定积累了很多知识,现在请认真、仔细地完成这张试题吧。加油! 一单项选择题 1. 在C语言中,以 D 作为字符串结束标志 A)’\n’ B)’’ C) ’0’ D)’\0’ 2.下列数据中属于“字符串常量”的是( A )。 A.“a” B.{ABC} C.‘abc\0’ D.‘a’ 若干个字符构成字符串 在C语言中,用单引号标识字符;用双引号标识字符串 选项B,C,分别用{}和’’标识字符串 选项D,标识字符。 3、以下说法中正确的是( C )。 A、C语言程序总是从第一个定义的函数开始执行 B、在C语言程序中,要调用的函数必须在main( )函数中定义 C、C语言程序总是从main( )函数开始执行 D、C语言程序中的main( )函数必须放在程序的开始部分 4.下列关于C语言的说法错误的是( B )。 A) C程序的工作过程是编辑、编译、连接、运行 B) C语言不区分大小写。 C) C程序的三种基本结构是顺序、选择、循环 D) C程序从main函数开始执行 5.下列正确的标识符是(C )。 A.-a1 B.a[i] C.a2_i D.int t 6.下列C语言用户标识符中合法的是( B )。 A)3ax B)x C)case D)-e2 E)union 7.下列四组选项中,正确的C语言标识符是( C )。 A) %x B) a+b C) a123 D) 123 8、下列四组字符串中都可以用作C语言程序中的标识符的是( A )。 A、print _3d db8 aBc B、I\am one_half start$it 3pai C、str_1 Cpp pow while D、Pxq My->book line# His.age 9.C语言中的简单数据类型包括(D )。 A、整型、实型、逻辑型 B、整型、实型、逻辑型、字符型 C、整型、字符型、逻辑型 D、整型、实型、字符型 10.在C语言程序中,表达式5%2的结果是 C 。 C语言的类和对象 【类实现了C++面向对象程序设计的基础,我们使用类来定义对象的属性,类是 C++封装的基本单元。】 一、----- 类 使用关键字class创建类,一个类声明定义了一个连接代码和一个数据的新类型,这个新的类型又可以用来声明该类的对象。因此,类又是逻辑逻辑抽象概念,儿对象是物理存在的,也就是说对象是类的实例。 类的声明语法上和结构相似。 [一下是完整的类的形式] class class_name { private data and functions access_specifier: data and functions access_specifiter: data and functions //…….. access_specifier:是 data and functions }object_list; 其中,object_list是任选项,如过存在,他声明类的对象。access_specifier为下面的三个关键字之一: Public private protected 默认时,在类声明的函数和数据属于该类私有,只能被该类的成员访问。如果使用,pubilc访问限定符号,函数和程序就可以被其他部分访问。Protected访问限定符,仅在涉及继承的时候才需要(十五章了解)。访问限定符已经使用,其作用就保持到遇到别的访问限定符或者达到类声明的结束处。 在类声明内可以任意改变访问说明符号,对于某些声明,可以转换位public,然后再转换成private。 [如下所述] /******************************* ··构造函数和析构函数学习··· *******************************/ //Using a constructor and destructor. /******************************* 声明C++ 程序头文件 *******************************/ #include C++实验报告 实验4 类与对象 一、实验目的 1、掌握类的声明和使用 2、掌握类的声明和对象的声明 3、复习具有不同访问属性的成员的访问方式 4、观察构造函数和析构函数的执行过程 5、学习类的组合使用方法 6、使用DEBUG调试功能观察程序流程,跟踪观察类的构造函数、析构函数、成员函数的执行顺序 二、实验任务 1、声明一个CPU类,包含等级rank、频率frequency、电压voltage等属性,有两个公有成员函数run、stop。其中,rank为枚举类型CPU-Rank,声明为enum CPU-Rank{P1=1,P2,P3,P4,P5,P6,P7}, frequency为MHz的整数型,voltage为浮点型的电压值。观察构造函数好析构函数的调用顺序。 2、声明一个简单的Computer类,有数据成员芯片cpu、内存ram、光驱cdrom 等,有两个公有成员函数run、stop。cpu为CPU类的一个对象,ram为RAM 类的一个对象,cdrom为CDROM类的一个对象,声明并实现这个类。 3、设计一个用于人事管理的People类。考虑到通用性,这里只抽象出所有类型人员都具有的属性:number编号、sex性别、birthday出生日期、id身份证号等。其中出生日期声明为一个日期类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括:构造函数和析构函数、拷贝构造函数、内嵌成员函数、组合。 三、实验内容 任务1:首先声明枚举类型,在这里出现了知识性错误,不清楚具体应如何声明,经查询相关书籍,知道应在类外进行声明。初次用类来进行编程,在概念上是有一些混乱的,例如构造函数和析构函数的调用顺序等。在用debug单步调试后,明白其中道理。 源程序: //Lab4_1.cpp #include (07837)《面向对象程序设计C++》复习题 一、单选题 1.对类成员访问权限的控制,是通过设置成员的访问控制属性实现的,下列不是访问控制属性的是( D ) A. 公有类型 B. 私有类型 C. 保护类型 D. 友元类型 2.下列关于多态性的描述,错误的是( C ) A. C++语言的多态性分为编译时的多态性和运行时的多态性 B. 编译时的多态性可通过函数重载实现 C. 运行时的多态性可通过模板和虚函数实现 D. 实现运行时多态性的机制称为动态绑定 3.在C++语言中,数据封装要解决的问题是( D ) A. 数据的规范化 B. 便于数据转换 C. 避免数据丢失 D. 防止不同模块之间数据的非法访问 4.使用private修饰的成员变量,以下说法正确的是( A ) A. 只能由本类中的函数使用,不能被外面的程序所访问。 B. 可以由本类中的函数使用,也可以被外面的程序所访问。 C. 只能由本类和派生类中的函数使用。 D. 可以在主函数中使用。 5.对类的构造函数和析构函数描述正确的是( A ) A. 构造函数可以重载,析构函数不能重载 B. 构造函数不能重载,析构函数可以重载 C. 构造函数可以重载,析构函数也可以重载 D. 构造函数不能重载,析构函数也不能重载 6.下面对静态数据成员的描述中,正确的是( A ) A. 静态数据成员是类的所有对象共享的数据 B. 类的每个对象都有自己的静态数据成员 C. 类的不同对象有不同的静态数据成员值 D. 静态数据成员不能通过类的对象调用 7.在VC++语言类体系中,不能被派生类继承的有( B ) A. 转换函数 B. 构造函数 C. 虚函数 D. 静态成员函数 8.下面关于句柄正确的说法是( A ) A. 句柄是一个标识Windows资源和设备等对象的变量。 B. 句柄是用户程序自定义的数据类型。 C. 用户程序使用句柄时不需要定义。 D. 句柄仅仅是一个抽象的概念,程序中不能使用句柄。 9.下面关于动态链接库正确的说法是( B ) A. 动态链接库提供的函数,在编译阶段能够连接到应用程序中。 B. 动态链接库提供的函数,在运行阶段能够连接到应用程序中。 C. 动态链接库本身不能单独设计、编译和调试。 D. 动态链接库的使用使得程序缺乏灵活性。 10.下面关于MFC应用程序中InitInstance函数正确的说法是( D ) A. 该函数由用户定义。 C 语言理论上机考试选择题部分(共200题) 1、下面程序的输出是___D______ #include a+=a-=a*a 后,a 的值是____D____ A) 552 B) 264 C) 144 D) -264 9、执行下面程序中的输出语句后,输出结果是____B__. #include 类和对象 一、选择题 1、下面对方法的作用描述不正确的是:( d ) A、使程序结构清晰 B、功能复用 C、代码简洁 D、重复代码 2、方法定义的变量:( b ) A 、一定在方法所有位置可见B、可能在方法的局部位置可见 C、在方法外可以使用 D、在方法外可见 3、方法的形参:(a) A、可以没有 B、至少有一个 C、必须定义多个形参 D、只能是简单变量 4、方法的调用:(c) A、必须是一条完整的语句 B、只能是一个表达式 C、可能是语句,也可能是表达式 D、必须提供实际参数 5、return 语句:( d) A、不能用来返回对象 B、只可以返回数值 C、方法都必须含有 D、一个方法中可以有多个return 语句 6、void 的含义:(d) A、方法体为空 B、方法体没有意义 C、定义方法时必须使用 D、方法没有返回值 7、main()方法的返回类型是:( c ) A 、boolean B、int C、void D、static 8、方法重载所涉及的方法:( a ) A、有相同的名字 B、参数个数必须不同 C、参数类型必须不同 D、返回类型必须不同 9、下面关于类和对象之间关系的描述,正确的是( c ) A、联接关系B、包含关系C、具体与抽象的关系D、类是对象的具体化 10、下面关于java中类的说法哪个是不正确的( c ) A、类体中只能有变量定义和成员方法的定义,不能有其他语句。 B、构造方法是类中的特殊方法。 C、类一定要声明为public的,才可以执行。 D、一个java文件中可以有多个class定义。 11、下列哪个类声明是正确的( d) A、public void H1{…} B 、public class Move(){…} C、public class void number{} D、public class Car{…} 12、下面的方法声明中,哪个是正确的(c) A、public class methodName(){} B、public void int methodName(){} C、public void methodName(){} D、public void methodName{} 13、下述哪些说法是不正确的?( b ) A、实例变量是类的成员变量 B、实例变量是用static关键字声明的 C、方法变量在方法执行时创建 D、方法变量在使用之前必须初始化 14、下面对构造方法的描述不正确是( b)。 A、系统提供默认的构造方法 B、构造方法可以有参数,所以也可以有返回值 C、构造方法可以重载 D、构造方法可以设置参数 15、定义类头时,不可能用到的关键字是( b)。 A、class B、private C、extends D、public 16、下列类头定义中,错误的是( )。 A、public x extends y {...} B、public class x extends y {...} C、class x extends y implements y1 {...} D、class x {...} 17、设A为已定义的类名,下列声明A类的对象a的语句中正确的是( ) 。 A、float A a; B、public A a=A( ); C、A a=new int( ); D、static A a=new A( ); 18、设i , j为类X中定义的int型变量名,下列X类的构造方法中不正确的是( a )。 A、void X(int k ){ i=k; } B、X(int k ){ i=k; } C、X(int m, int n ){ i=m; j=n; } D、X( ){i=0;j=0; } 19、有一个类A,以下为其构造方法的声明,其中正确的是 实验九类和对象的使用实验报告 一实验目的 1、学会用构造函数对类对象进行初始化 2、掌握析构函数,并了解构造函数和析构函数的调用顺序 3、了解对象数组和对象指针的用法 4、学会共用数据的保护,了解常对象、常成员函数等的使用限制 二实验内容和要求 1.回顾课本知识,掌握重点和难点,认真分析例题熟悉本章内容。 2.完成本章课后习题2、6、7题,认真分析每一题的代码。 三实验环境 Visual C++6.0开发环境 四源程序 2、 #include Date::Date() { month=1; day=1; year=2005; } void Date::display() { cout< 第3章类与对象 一.选择题 1.下列不属于面向对象编程的特性是(D)。 A.封装性 B. 继承性 C. 多态性 D. 编译执行 2.下列类的声明中不合法的是(C)。 A. class People{…} B. class 植物{…} C. Class A{…} D. public class 共有类{… 3.下列方法的声明中不合法的是(C)。 A. float area(){…} B. void area(){…} C. double area(d){…} D. int area(int r){…} 4. 下列构造方法(构造器)的调用中正确的是(C)。 A. 按照一般的方法调用 B. 由用户直接调用 C. 只能通过new自动调用 D. 被系统调用 5.下列程序运行的结果是(A)。 class Book{ int width; int length; } public class A{ static void f(Book p){ p.width=20; p.length=40; } public static void main(String args[]){ Book b=new Book(); b.width=10; b.length=20; f(b); System.out.print(" "+b.width); System.out.print(" "+b.length); } } A. 20 40 B. 10 40 C. 10 20 D. 以上都不对 6.下列程序运行的结果是(D)。 public class A{ static void f(int y){ y=y+10; } public static void main(String args[]){ double x=10; f(x); System.out.println(x); } } ================================================== 题号:1482 执行以下程序段后,输出结果和a的值是()。int a=10; printf("%d",a++); A、11 和10 B、11 和11 C、10 和11 D、10 和10 答案: C 题号:2100 已知字符'A'的ASCⅡ代码值是65,字符变量c1的值是'A',c2的值是'D'.执行语句printf("%d,%d",c1,c2-2);后,输出结果是 A、65,66 B、A,B C、65,68 D、A,68 答案: A 题号:5055 相同结构体类型的变量之间,可以()。 A、比较大小 B、地址相同 C、赋值 D、相加 答案: C 题号:3217 int a[10];合法的数组元素的最小下标值为()。 A、1 B、0 C、10 D、9 答案: B 能正确表示逻辑关系:" a≥10或a≤0 "的C语言表达式是 A、a>=0 | a<=10 B、a>=10 or a<=0 C、a>=10 && a<=0 D、a>=10 || a<=0 答案: D 题号:157 main() {int x=1,a=0,b=0; switch (x) { case 0: b++; case 1: a++; case 2: a++;b++;} printf("a=%d,b=%d",a,b); }该程序的输出结果是( ) A、2,2 B、2,1 C、1,1 D、1,0 答案: B 题号:4784 设变量a是整型,f是实型,i是双精度型,则表达式10+'a'+i*f值的 数据类型为()。 A、不确定 B、double C、int D、float 答案: B 题号:1647 以下程序中,while循环的循环次数是______ main() { int i=0; 计算机科学与技术实验报告 实验二类和对象(1) 姓名:易XX 班级:计科二班学号:2015110121 实验目的:深入理解类和对象,学会定义类,申明私有、公有变量,学会定义对象,并调用成员函数,解决实际问题。 实验内容: (一)、题目要求: 定义一个描述角度的类CAngle,包含的内容如下: (1)私有成员变量value,表示角度,类型为double; (2)公有成员变量SetValue,实现功能是使用形参为value赋值。 声明为:viod SetValue(double); (3)公有成员函数GetCos,实现功能计算余弦值,并作为返回值返回。 声明为 double GetCos(); 编程实现如下功能:定义一个Cangle类的对象deg,调用成员函数设置deg的角度为30度,调用成员函数计算并输出deg的余弦值。 代码: #include 实验四数组、指针与字符串 1.实验目的 1.学习使用数组 2.学习字符串数据的组织和处理 3.学习标准C++库的使用 4.掌握指针的使用方法 5.练习通过Debug观察指针的内容及其所指的对象的内容 6.联系通过动态内存分配实现动态数组,并体会指针在其中的作用 7.分别使用字符数组和标准C++库练习处理字符串的方法 2.实验要求 1.编写并测试3*3矩阵转置函数,使用数组保存3*3矩阵。 2.使用动态内存分配生成动态数组来重新完成上题,使用指针实现函数的功能。 3.编程实现两字符串的连接。要求使用字符数组保存字符串,不要使用系统函数。 4.使用string类定义字符串对象,重新实现上一小题。 5.定义一个Employee类,其中包括姓名、街道地址、城市和邮编等属性,以及change_name()和display()等函数。Display()显示姓名、街道地址、城市和邮编等属性,change_name()改变对象的姓名属性。实现并测试这个类。 6.定义包含5个元素的对象数组,每个元素都是Employee类型的对象。 7. (选做)修改实验4中的选做实验中的people(人员)类。具有的属性如下:姓名char name[11]、编号char number[7]、性别char sex[3]、生日birthday、身份证号char id[16]。其中“出生日期”定义为一个“日期”类内嵌对象。用成员函数实现对人员信息的录入和显示。要求包括:构造函数和析构函数、拷贝构造函数、内联成员函数、聚集。在测试程序中定义people类的对象数组,录入数据并显示。 3.实验内容及实验步骤 1.编写矩阵转置函数,输入参数为3*3整形数组,使用循环语句实现矩阵元素的行列对调,注意在循环语句中究竟需要对哪些元素进行操作,编写main()函数实现输入、输出。程序名:lab6_1.cpp。 2.改写矩阵转置函数,参数为整型指针,使用指针对数组元素进行操作,在main()函数中使用new操作符分配内存生成动态数组。通过Debug观察指针的内容及其所指的对象中的内容。程序名:lab6_2.cpp。 3.编程实现两字符串的连接。定义字符数组保存字符串,在程序中提示用户输入两个字符串,实现两个字符串的连接,最后用cout语句显示输出。程序名:lab6_3.cpp。用cin实现输入,注意,字符串的结束标志是ASCII码0,使用循环语句进行字符串间的字符拷贝。 4.使用string类定义字符串对象,编程实现两字符串的连接。在string类中已重载了运算符“+=”实现字符串的连接,可以使用这个功能。程序名:lab6_4.cpp。 5.在employee.h文件中定义Employee类。Employee类具有姓名、街道地址、城市和邮编等私有数据成员,在成员函数中,构造函数用来初始化所有数据成员;display()中使用cout显示 C语言 一、选择题(第题2分,共20分) 1.一个C程序的执行是从 A 。 A) 本程序的main函数开始,到main函数结束 B) 本程序文件的第一个函数开始,到本程序文件的最后一个函数结束 C) 本程序文件的第一个函数开始,到本程序main函数结束 D) 本程序的main函数开始,到本程序文件的最后一个函数结束 2.若x、i、j、k都是int型变量,则计算下面表达式后,x的值为 C 。 x=(i=4,j=16,k=32) A) 4 B) 16 C) 32 D) 52 3.设C语言中,一个int型数据在内存中占2个字节,则unsigned int 型数据的取值范围为 C 。 A) 0~255 B) 0~32767 C) 0~65535 D) 0~2147483647 4.设有说明:char w; int x; float y; double z;则表达式w*x+z-y值的数据类型为 D 。 A) float B) char C) int D) double 5. putchar函数可以向终端输出一个 D 。 A) 整型变量表达式 B) 实型变量值 C) 字符串 D) 字符或字符型变量值 6. printf函数中用到格式符%5s,其中数字5表示输出的字符串占用5列。如果字符串长度大于5,则输出按方式 B ;如果字符串长度小于5,则输出按方式 C 。 A) 从左起输出该字符串,右补空格 B) 按原字符长从左向右全部输出 C) 右对齐输出该字符串,左补空格 D) 输出错误信息 7.判断char型变量ch是否为大写字母的正确表达式是 C 。 A) ‘A’<=ch<=‘Z’ B) (ch>=‘A’)&(ch<=‘Z’) C) (ch>=‘A’)&&(ch<=‘Z’) D) (‘A’<= ch)AND(‘Z’>= ch) 8.已知int x=10,y=20,z=30;以下语句执行后x,y,z的值是 B 。 if(x>y) z=x; x=y; y=z; A) x=10, y=20, z=30 B) x=20, y=30, z=30 C) x=20, y=30, z=10 D) x=20, y=30, z=20 9.以下程序段______C__. x=-1; do{ x=x*x; } while(!x); A)是死循环 B)循环执行二次 C)循环执行一次 D)有语法错误 10.以下正确的描述是___B____. A)continue语句的作用是结束整个循环的执行 浙江理工大学信息学院 面向对象程序设计实验报告 实验名称:类的定义与使用学时安排:3 实验类别:设计性实验实验要求:1人1组姓名:邵旸珂学号:2016329621068  ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄一、实验目的 1)掌握类的概念、类的定义格式、类与结构的关系、类的成员属性和类的封装性; 2)掌握类对象的定义; 3)理解类的成员的访问控制的含义,公有、私有和保护成员的区别; 4)掌握构造函数和析构函数的含义与作用、定义方式和实现,能够根据要求正确定义和重载构造函数。能够根据给定的要求定义类并实现类的成员函数; 二、实验原理介绍 通过建立类及对象,用类的成员函数和对象访问类的成员; 利用建立类的构造函数,完成类的成员的初始化工作; 三、实验设备介绍 软件需求: windows或linux下的c++编译器 硬件需求: 对于硬件方面的要求,建议配置是Pentium III 450以上的CPU 处理器,64MB以上的内存,200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。 四、实验内容 编写一个程序,模拟电梯的功能。功能接口包括电梯上行按钮、下行按钮、楼层选择和电梯在行驶过程中的楼层显示。 要求: 1.由用户选择按上行按钮还是下行按钮,选择操作后再由用户输入要进入的楼层,进而电梯开始运行,显示所到的每一楼层层数。 2.如果是上行,则选择输入的楼层号不能比当前楼层号小,否则应给出不合法提示。 3. 如果是下行,则选择输入的楼层号不能比当前楼层号大,否则应给出不合法提示。 4.电梯一旦开始运作就会始终运行,直到窗口关闭。 5.电梯在经过不同楼层时,最好每个楼层的显示之间能有延迟,最终停靠的楼层的输出形式能更加醒目。如果可以,在电梯最初开始运行时,能在电梯由内部显示当前日期(提示:实现这些功能时,需要调用系统api,实现时间显示功能可以使用CDate类)。 五程序清单 #include 类和对象(一) 知识点: 1.类与对象的概念,及两者的关系? 2.类定义的格式,对象定义的格式,访问对象的成员的格式 3.类中成员访问权限有哪几种,它们的特点? 4.如何对对象进行初始化? 5.构造函数与析构函数的特点,构造函数在哪些情况下被系统自动调用,析构函数什么情况下被调用;存在虚基类的派生类构造函数调用顺序? 6.缺省构造函数的特点 7.拷贝构造函数的功能与特点 8.成员函数与内联函数的区别 9.静态成员的概念与作用 10.静态成员函数调用格式 11.什么是友元,友元的作用 12.作用域运算符的功能是什么?它的使用格式如何? 13.满足成员函数重载的条件 作业题 一、选择填空 1.在下列关键字中,用以说明类中公有成员的是( )。 A .public;B.private;C.protected;D.friend。 2.下列的各类函数中,( )不是类的成员函数。 A.构造函数;B.析构函数;C.友员函数;D.拷贝初始化构造函数。 3.作用域运算符的功能是( )。 A.标识作用域的级别的; B.指出作用域的范围的; C.给出作用域的大小的; D.标识某个成员是属于哪个类的。 4.( )是不可以作为该类的成员的。 A.自身类对象的指针; B.自身类的对象; C.自身类对象的引用; D.另一个类的对象。 5.( )不是构造函数的特征。 A.构造函数的函数名与类名相同; B.构造函数可以重载; C.构造函数可以重载设置缺省参数; D.构造函数必须指定类型说明。 6.( )是析构函数的特征。 A.一个类中能定义一个析构函数; B.析构函数名与类名不同; C.析构函数的定义只能在类体内; D.析构函数可以有一个或多个参数。 7.通常的拷贝初始化构造的参数是( )。 A.某个对象名; B.某个对象的成员名; C.某个对象的引用名; D.某个对象的指针名。 8.关于成员函数特征的下述描述中,( )是错误的。 一、问答题 1、局部变量能否和全局变量重名? 答:能,局部会屏蔽全局。要用全局变量,需要使用 ":: " 局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器而言,在同一个函数内可以定义多个同名的局部变量,比如在两个循环体内都定义一个同名的局部变量,而那个局部变量的作用域就在那个循环体内。 2、如何引用一个已经定义过的全局变量? 答:extern 可以用引用头文件的方式,也可以用extern关键字,如果用引用头文件方式来引用某个在头文件中声明的全局变理,假定你将那个变写错了,那么在编译期间会报错,如果你用extern方式引用时,假定你犯了同样的错误,那么在编译期间不会报错,而在连接期间报错。 3、全局变量可不可以定义在可被多个.C文件包含的头文件中?为什么? 答:可以,在不同的C文件中以static形式来声明同名全局变量。 可以在不同的C文件中声明同名的全局变量,前提是其中只能有一个C文件中对此变量赋初值,此时连接不会出错 4、语句for( ;1 ;)有什么问题?它是什么意思? 答:和while(1)相同。 5、do……while和while……do有什么区别? 答:前一个循环一遍再判断,后一个判断以后再循环 6、请写出下列代码的输出内容 #include C语言题库及答案
C语言的类和对象
C++实验报告 第四章 类与对象
面向对象程序设计C自学考试课程复习题
C语言考试题库及答案复习整理
类和对象练习题
C++实验九类和对象的使用实验报告
JAVA基础-第3章类与对象-练习题-200910
大学c语言考试题库含答案
C++类和对象实验报告
C上机实验报告实验四
(完整版)C语言试题及答案解析
实验一.类与对象实验报告
C面向对象程序设计习题 类与对象
[整理]C语言试题及答案.
C++ 实验二 类与对象(附答案)