c++类与对象习题答案

最新推荐文章于 2023-05-06 16:12:08 发布

叁佰_542586

最新推荐文章于 2023-05-06 16:12:08 发布

阅读量3.1k

点赞数 3

分类专栏： # C++习题考试复习题目汇总文章标签： c++

本文链接：https://blog.csdn.net/csq542586/article/details/116329999

版权

C++习题考试复习题目汇总专栏收录该内容

9 篇文章 88 订阅

订阅专栏

概念填空题

1.1 类定义的关键字是 class 。类的数据成员通常指定为私有成员。类的函数成员通常指定为公有成员,指定为公有的类成员可以在类对象所在域中的任何位置访问它们，类的私有和保护只能被该类的成员函数或友元函数访问。

1.2类的访问限定符包括 public、 private 和 protected 。类成员默认的访问方式是 private 。访问限定符在类中无先后次序，各限定符允许 (允许/不允许)多次出现。

1.3 构造函数的任务是建立对象。类中可以有多个构造函数,它们由参数区分。如果类说明中没有给出构造函数,则C++编译器会提供构造函数，该函数不完成（完成/不完成）对象初始化工作。

1.4复制构造函数的参数是对象的复制 ,当程序没有给出复制构造函数时,编译系统会提供默认复制构造函数 ,完成类对象的复制。复制构造函数被调用情况有 3 种。

1.5析构函数在对象释放时被自动调用。类中没有定义析构函数时，编译系统会提供一个默认的析构函数。该函数不完成（完成/不完成）具体对象的清理工作。

2. 简答题

2.1 为什么说类与对象的概念是客观世界的反映?

2.2 简单解释什么是面向对象程序设计的封装性。

2.3 引用作为函数参数时为什么能实现两个实参之间的数据交换?为什么对应实参不能为引用?为什么返回值为引用的函数可以作为左值?

2.4 什么是默认的构造函数?默认的构造函数可以有多少个?

2.5 复制构造函数用于哪3个方面?

2.6 为什么在友元函数的函数体内访问对象成员时,必须用对象名加运算符”.”再加对象成员名?

2.7 类的静态数据成员与函数中的静态成员有何异同?

2.8 类的成员函数在什么情况下应该定义为私有的?这样做的目的是什么?

2.9 友元关系有何性质？友元关系的优点和缺点各有哪些？

3.选择题

3.1 数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是（ B ）。

A．类 B．对象 C．函数体 D．数据块

3.2 类的实例化是指（ B ）。

A．定义类 B．创建类的对象 C．指明具体类 D．调用类的成员

3.3下列说法中正确的是（ B ）。

A．类定义中只能说明函数成员的函数头，不能定义函数体

B．类中的函数成员可以在类体中定义，也可以在类体之外定义

C．类中的函数成员在类体之外定义时必须要与类声明在同一文件中

D．在类体之外定义的函数成员不能操作该类的私有数据成员

3.4有如下类定义：

class sample {

int n;

public:

sample (int i=0):n(i){ }

void setValue(int n0);

}；

下列关于setValue成员函数的实现中，正确的是（ B ）。

A．sample::setValue(int n0){n=n0;}

B．void sample::setValue(int n0){n=n0;}

C．void setValue(int n0){n=n0;}

D．setValue(int n0){n=n0;}

3.5在下面的类定义中，错误的语句是（ C ）。

class sample{

public:

sample(int val); //①

~sample( ); //②

private:

int a=2.5; //③

public:

sample( ); //④

};

A．① B．② C．③ D．④

3.6类的构造函数被自动调用执行的情况是在创建该类的（C）。

A．成员函数时 B．数据成员时

C．对象时 D．友元函数时

3.7（A）是析构函数的特征。

A．一个类中只能定义一个析构函数

B．析构函数名与类名不同

C．析构函数的定义只能在类体内

D．析构函数可以有一个或多个参数

3.8 在下列函数原型中，可以作为类AA构造函数的是（ D ）。

A．void AA(int)； B．int AA( )；

C．AA(int) const； D．AA(int)

3.9关于成员函数特征的下述描述中，（A）是错误的。

A．成员函数一定是内联函数

B．成员函数可以重载

C．成员函数可以设置参数的默认值

D．成员函数可以是静态的

3.10不属于成员函数的是（B ）。

A．静态成员函数 B．友元函数

C．构造函数 D．析构函数

3.11已知类A是类B的友元，类B是类C的友元，则（C ）。

A．类A一定是类C的友元

B．类C一定是类A的友元

C．类C的成员函数可以访问类B的对象的任何成员

D．类A的成员函数可以访问类B的对象的任何成员

3.12有如下类定义：

class AA{

int a;

public:

int getRef( ) const {return &a;} //①返回类型为int, return &a为地址

int getValue( ) const {return a;} //②

void set(int n) const{a=n;} //③常函数不能修改成员

friend void show(AA aa) const {cout<<a;} //④友元函数不能是常函数

}；

其中的四个函数定义中正确的是（B）。

A． ① B．② C．③ D．④

3.13有如下类定义：

class Test{

public:

Test( ){a=0;c=0;} //①常成员必须在初始化列表中初始化

int f(int a) const {this->a=a;} //②常函数不能修改成员

void h(int b) {Test::b=b;}; //③

static int g( ) {return a;} //④静态函数要通过对象访问成员

private:

int a;

static int b;

const int c;

};

int Test::b=0;

在标注号码的行中，能被正确编译的是（C）。

A．① B．② C． ③ D．④

4写出程序程序执行结果。

4.1#include<iostream>

using namespace std;

class Test {

public:

Test( ) { n+=2; }

~Test( ) { n-=3;}

static int getNum( ) { return n;}

private:

static int n;

};

int Test::n=1;

int main( ){

Test* p = new Test;

delete p;

cout<<”n=”<<Test::getNum( )<<endl;

return 0;

}

n=0

4.2#include<iostream>

using namespace std;

class AA{

int n;

public:

AA(int k):n(k){}

int get( ) {return n;}

int get( ) const{ return n+1;}

};

int main( ){

AA a(5);

const AA b(6);

cout<<a.get()<<”,”<<b.get();

return 0;

}

5 7

4.3#include<iostream>

using namespace std;

class MyClass {

public:

int number;

void set(int i);

};

int number=3;

void MyClass::set (int i){

number=i;

}

void main( ){

MyClass my1;

int number=10;

my1.set(5);

cout<<my1.number<<endl;

my1.set(number);

cout<<my1.number<<endl;

my1.set(::number);

cout<<my1.number;

}

5 10 3

4.4#include<iostream>

using namespace std;

class Test{

private:

static int val;

int a;

public:

static int func( );

void sfunc(Test &r);

};

int Test::val=200;

int Test::func( ){

return val++;

}

void Test::sfunc(Test &r){

r.a=125;

cout<<"Result3="<<r.a<<endl;

}

void main( ){

cout<<"Result1="<<Test::func( )<<endl;

Test a;

cout<<"Result2="<<a.func()<<endl;

a.sfunc(a);

}

Result1=200

Result2=201

Result1==125

5.编程题

5.1 构造一个日期时间类(Timedate),数据成员包括年、月、日和时、分、秒,函数成员包括设置日期时间和输出时间,其中年、月用枚举类型,并完成测试(包括用成员函数和用普通函数)。

#include <iostream.h>

#include <conio.h>

#include <iomanip.h>

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<<'/'<<date<<endl;

cout<<"hour:minite:second :";

cout<<hh<<':'<<mm<<':'<<ss<<endl;

}

void show(Timedate &td){//普通函数,体会两者的不同

YR year;

MT month;

int date,hh,mm,ss;

td.getdate(year,month,date);

td.gettime(hh,mm,ss);

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<<'/'<<date<<endl;

cout<<"hour:minite:second :";

cout<<hh<<':'<<mm<<':'<<ss<<endl;

}

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();

show(B);

return 0;

}

5.2 定义一个日期类Date,具有年月日等数据成员，显示日期、加减天数等函数成员。注意需要考虑闰年。

#include <iostream>

using namespace std;

class Date{

int year,month,day;

static const int days[];

bool LeapYear();

bool EndofMonth();

public:

Date(int=1900,int=1,int =1);

void Increment(int );

void Decrement(int);

void SetDate(int,int,int);

void Print();

};

const int Date::days[]={0,31,28,31,30,31,30,31,31,30,31,30,31};

Date::Date(int y,int m,int d){

SetDate(y,m,d);

}

void Date::SetDate(int y,int m,int d){

year=(y>=1900 && y<=9999)?y:1900;

month=(m>=1 &&m<=12)?m:1;

if(month==2 && LeapYear())

day=(d>=1 && d<=29)?d:1;

else

day=(d>=1 && d<=days[month])?d:1;

}

bool Date::LeapYear(){

return ((year%400 == 0) || (year%4==0 && year%100!=0))? true:false;

}

bool Date::EndofMonth(){

if(month==2 && LeapYear())

return day==29;

else

return day==days[month];

}

void Date::Increment(int n){

int i;

for(i=1;i<=n;i++)

if(EndofMonth() && month==12){

year++; month=day=1;

}

else if(EndofMonth()){

month++;day=1;

}

else

day++;

}

void Date::Decrement(int n){

int i;

for(i=1;i<=n;i++)

if(day==1){

if(month==1){

year--; month=12; day=31;

}

else if(month==3){

day=LeapYear()?29:28; month=2;

}

else

day=days[--month];

}

else

day--;

}

void Date::Print(){

cout<<year<<"-"<<month <<"-"<<day <<endl;

}

void main(){

Date d1(2005,1,4),d2(2004,12,27);

d1.Print();

d1.Decrement(4);

d1.Print();

d2.Print();

d2.Increment(70);

d2.Print();

}

5.3 定义一个圆类(Circle),属性为半径(radius)、圆周长和面积,操作为输入半径并计算周长、面积,输出半径、周长和面积。要求定义构造函数(以半径为参数,默认值为0,周长和面积在构造函数中生成)和复制构造函数。

#include <iostream>

const double PI=3.1415;

using namespace std;

class Circle{

double radius,length,area;

public:

Circle(double r=0){

setr(r);

length=2*PI*radius;

area=PI*radius*radius;

}

Circle(Circle& c){

radius=c.radius ;

length=c.length ;

area=c.area ;

}

void print(){

cout<<"radius= "<<radius<<endl;

cout<<"length= "<<length<<endl;

cout<<"area= "<<area<<endl;

}

void setr(double r){

radius=r;

}

};

int main(){

Circle c1(10),c2(c1);

c1.print();

c2.print();

return 0;

}

5.4 设计一个学校在册人员类(Person)。数据成员包括身份证号(IdPerson)、姓名(Name)、性别(Sex)、生日(Birth-day)和家庭住址(HomeAddress)。成员函数包括人员信息的录入和显示,还包括构造函数与复制构造函数。设计一个合适的初始值。

#include <iostream>

#include <cstring>

const double PI=3.1415;

using namespace std;

struct date{

int year,month,day;

};

class Person{

char ID[12];

char Name[10];

char Sex[3];

date Birth;

char HomeAdd[20];

public:

Person(){

ID[0]=Name[0]=Sex[0]=HomeAdd[0]=0;

Birth.year=Birth.month=Birth.day=0;

}

Person(char id[],char name[],char sex[],date birth,char homeadd[]){

strcpy(ID,id);

strcpy(Name,name);

strcpy(Sex,sex);

Birth=birth;

strcpy(HomeAdd,homeadd);

}

Person(Person& p){

strcpy(ID,p.ID);

strcpy(Name,p.Name);

strcpy(Sex,p.Sex);

Birth=p.Birth;

strcpy(HomeAdd,p.HomeAdd);

}

void setID(char id[]){

strcpy(ID,id);

}

void setName(char name[]){

strcpy(Name,name);

}

void setSex(char sex[]){

strcpy(Sex,sex);

}

void setBirth(date birth){

Birth=birth;

}

void setHome(char homeadd[]){

strcpy(HomeAdd,homeadd);

}

void print(){

cout<<"ID= "<<ID<<",Name= "<<Name<<",Sex= "<<Sex<<",";

cout<<"Birth= "<<Birth.year<<"-"<<Birth.month<<"-"<<Birth.day<<",";

cout<<HomeAdd<<endl;

}

};

int main(){

date birth;

birth.year =1991;

birth.month =6;

birth.day =12;

Person p1("08124401","陈建华","男",birth,"中吴大道1801号");

p1.print ();

Person p2;

p2.print ();

return 0 ;

}

5.5设计如下类：

1)建立一个Point类，表示平面中的一个点；建立一个Line类，表示平面中的一条线端，内含两个Point类的对象；建立Triangle类，表示一个三角形，内含三个Line类的对象构成一个三角形。

2）设计三个类的相应的构造函数、复制构造函数，完成初始化和对象复制

3）设计Triangle类的成员函数完成三条边是否能构成三角形的检验和三角形面积计算，面积显示。

#include <iostream>

#include <cmath>

const double PI=3.1415;

using namespace std;

class Point{

double X,Y;

public:

Point(double x=0,double y=0){

X=x;Y=y;

}

Point(Point& p){

X=p.X ; Y=p.Y ;

}

double getx(){return X;}

double gety(){return Y;}

};

class Line{

Point pstart,pend;

double length;

public:

Line(Point p1,Point p2):pstart(p1),pend(p2){

setl();

}

Line(Line& l):pstart(l.pstart),pend(l.pend){

setl();

}

double getl(){return length;}

void setl(){

double deltax,deltay;

deltax=pstart.getx()-pend.getx();

deltay=pstart.gety()-pend.gety();

length=sqrt(deltax*deltax+deltay*deltay);

}

};

class Trangle{

Line lfirst,lsecond,lthird;

double area;

public:

Trangle(Line lf,Line ls,Line lt):lfirst(lf),lsecond(ls),lthird(lt){

area=0;

}

bool check(){

double l1,l2,l3;

l1=lfirst.getl();

l2=lsecond.getl();

l3=lthird.getl();

return l1<l2+l3 && l2<l1+l3 && l3<l1+l2;

}

void calarea(){

if (check()){

double s;

double l1,l2,l3;

l1=lfirst.getl();

l2=lsecond.getl();

l3=lthird.getl();

s=(l1+l2+l3)/2.0;

area=sqrt(s*(s-l1)*(s-l2)*(s-l3));

}

void print(){

cout<<"area= "<<area<<endl;

}

};

int main(){

Point p1,p2(4,0),p3(0,3);

Line l1(p1,p2),l2(p1,p3),l3(p2,p3);

Trangle t(l1,l2,l3);

if(t.check ())t.calarea();

t.print();

return 0;

}

5.6建立一个分数类Fraction。分数类的数据成员包括分子和分母。成员函数包括构造函数、复制构造函数。构造函数要对初始化数据进行必要的检查(分母不能为0)。将分数显示成 “a/b”形式的输出函数。成员函数包括约分、通分、加、减、乘、除、求倒数、比较大小、显示和输入。完成以上所有成员函数并在主函数中进行检验。

#include <iostream>

using namespace std;

class Fraction{

int numerator,denominator;

int common_divisor(); //计算最大公约数

void contracted(); //分数化简

public:

Fraction(int=0,int=1);

Fraction(Fraction&);

Fraction Add(Fraction);

Fraction Sub(Fraction);

Fraction Mul(Fraction);

Fraction Div(Fraction);

bool operator>=(Fraction);

bool operator<=(Fraction);

bool operator==(Fraction);

bool operator<(Fraction f){return !(operator>=(f));}

bool operator>(Fraction f){return !(operator<=(f));}

bool operator!=(Fraction f){return !(operator==(f));}

Fraction Updown();

void Set(int=0,int=1);

void disp(){cout<<"fraction= "<<numerator<<"/"<<denominator<<endl;}

};

Fraction::Fraction(int num,int deno){

Set(num, deno);

}

Fraction::Fraction(Fraction& f){

numerator=f.numerator;

denominator=f.denominator;

}

Fraction Fraction::Add(Fraction f){

Fraction Temp(numerator*f.denominator+f.numerator*denominator,denominator*f.denominator);

Temp.contracted();

return Temp;

}

Fraction Fraction::Sub(Fraction f){

Fraction Temp(numerator*f.denominator-f.numerator*denominator,denominator*f.denominator);

Temp.contracted();

return Temp;

}

Fraction Fraction::Mul(Fraction f){

Fraction Temp(numerator*f.numerator,denominator*f.denominator);

Temp.contracted();

return Temp;

}

Fraction Fraction::Div(Fraction f){

Fraction Temp(f.denominator,f.numerator );

Temp=Mul(Temp);

Temp.contracted();

return Temp;

}

int Fraction::common_divisor(){

int residue;

int dividend=numerator,divisor=denominator;

while(residue=dividend%divisor){

dividend=divisor;

divisor=residue;

}

return divisor;

}

void Fraction::contracted()

{

int residue=common_divisor();

numerator/=residue;

denominator/=residue;

if(denominator<0){numerator*=-1;denominator*=-1;}

}

bool Fraction::operator>=(Fraction f){

Fraction Temp=Sub(f);

return (Temp.numerator >=0);

}

bool Fraction::operator<=(Fraction f){

Fraction Temp=Sub(f);

return (Temp.numerator <=0);

}

bool Fraction::operator==(Fraction f){

Fraction Temp=Sub(f);

return (Temp.numerator ==0);

}

Fraction Fraction::Updown(){

int p;

Fraction Temp;

if (numerator!=0){

p=numerator;

numerator=denominator;

denominator=p;

Temp.numerator=numerator;

Temp.denominator=denominator;

}

return Temp;

}

void Fraction::Set(int num,int deno){

if(deno!=0){

numerator=num;denominator=deno;

contracted();

}

void main(){

Fraction f1(1,3),f2=2,f3,f4,f5(2,8),f6,f7(8,3),f8(8,3),f9(1,4);

f4=f1.Add(f2);

f4.disp();

f6=f2.Div(f5).Div(f7);

f6.disp();

f5.disp();

f6=f1.Sub(f2);

f6.disp();

f9.Set(5,3);

f9.disp();

f9.Updown();

f9.disp();

cout<<(f7==f8)<<endl;

cout<<(f7==f1)<<endl;

cout<<(f5==f9)<<endl;

cout<<(f1>f2)<<endl;

}

叁佰_542586

关注

3
点赞
踩
37

收藏

觉得还不错? 一键收藏
打赏
0
评论
c++类与对象习题答案

概念填空题1.1 类定义的关键字是 class 。类的数据成员通常指定为私有成员。类的函数成员通常指定为公有成员,指定为公有的类成员可以在类对象所在域中的任何位置访问它们，类的私有和保护只能被该类的成员函数或友元函数访问。1.2类的访问限定符包括 public、 private 和 protected 。类成员默认的访问方式是 private 。访问限定符在类中无先后次序，各限定符允许 (允许/不允许)多次出现。1.3 构造函数的任务是建立对象。类中可以有多 ...
复制链接

扫一扫