|
|
《面向对象程序设计》课程复习大纲与练习题
课程名称 面向对象程序设计
教
材
信
息 名称 C++程序设计教程
出版社 南开大学出版社
作者 李敏，王刚，崔宝深编著
版次 2005
注：如学员使用其他版本教材，请参考相关知识点
第一章 初识C++
一、程序设计的基本概念：了解结构化程序设计和面向对象程序设计的思想。
二、高级程序设计语言C++：了解C++语言的发展历史和特点，掌握Microsoft Visual C++ 6.0继承开发环境的使用。
三、第一个C++程序：掌握C++程序的组成及各组成部分的作用。
四、C++与C的主要差异：掌握C++与C的主要差异。
第二章 类与对象
一、对象和类的概念：理解对象和类的概念及二者之间的关系。
二、类和对象的定义：掌握类定义方法、类中成员函数的定义方法、对象的定义方法、类成员的访问方法，理解访问限定符的作用。
三、构造函数和析构函数：理解构造函数、析构函数和拷贝构造函数的作用和调用时机，理解浅拷贝的问题和深拷贝的作用，掌握构造函数、析构函数和拷贝构造函数的定义方法。
四、静态成员：理解静态成员的作用，掌握静态成员的定义方法和访问方法，掌握静态数据成员的初始化方法，理解静态成员函数中不能访问非静态成员的原因。
五、友元：理解友元函数和友类的作用，掌握友元函数和友类的声明方法，理解类名声明的作用。
六、this指针：理解this指针的作用，掌握this指针的使用方法。
七、string类：理解string类的作用，掌握string类对象的初始化方法和常用操作方法。
第三章 继承
一、继承的概念：理解继承的概念和作用，了解继承与合成的区别。
二、单继承：掌握派生类的定义与访问方法，掌握派生类构造函数和析构函数的定义方法和调用时机，理解三种不同继承方式的作用。
三、类型兼容：理解类型兼容的作用，掌握类型兼容的三种应用情况。
四、多重继承：理解多重继承的作用，掌握多重继承的定义方法，理解多重继承中可能出现的二义性问题，掌握通过虚拟继承解决二义性问题的方法。
第四章 多态性与虚函数
一、多态性：理解多态性的含义，以及先期绑定和后期绑定的区别。
二、虚函数：理解虚函数的工作方式，掌握虚函数的声明方法，理解虚析构函数的作用，掌握虚函数的正确使用方法。
三、抽象类：理解抽象类的作用，掌握抽象类的定义方法。
第五章 运算符重载
一、运算符重载：理解运算符重载的作用，了解可以被重载的运算符，掌握运算符重载的定义形式和规则，掌握以类成员和非类成员实现运算符重载的两种方式。
二、友元重载：理解友元重载的作用，掌握友元重载的声明方法。
三、重载赋值运算符：掌握赋值运算符重载的实现方式。
四、重载操作符++和--：掌握前增量（或前减量）和后增量（或后减量）两种运算符的重载方式。
第六章 IO流
一、C++流概述：了解IO流类的结构和C++预定义的4个标准流对象的含义，掌握标准输出流对象和标准输入流对象的使用方法。
二、文件操作：理解文件中数据的组织方式和文件指针的含义，了解文件流类的结构，掌握文件操作方法。
三、“<<”和“>>”运算符重载：掌握“<<”和“>>”运算符重载的作用和使用方法。
第七章 模板
一、函数模板：理解函数模板的作用和工作方式，掌握函数模板的定义方式和使用方法。
二、类模板：理解类模板的作用和工作方式，掌握类模板的定义方式和使用方法。
期末综合练习题
一、读程序写结果
1、下面程序的运行结果为 0 1 2 3 4 。
#include <iostream>
using namespace std;
#define size 5
void get(int &n,int i)
{
n=i;
}
void print(int *n)
{
for(int i=0;i<size;i++)
cout<<n<<" ";
}
int main()
{
int a[size];
for(int i=0;i<size;i++)
get(a,i);
print(a);
return 0;
}
2、下面程序的运行结果为 1 2 3 4 5
1 9 3 4 5 。
#include <iostream>
using namespace std;
int nArray[] = {1, 2, 3, 4, 5};
int& Index(int nI)
{
return nArray[nI];
}
int main()
{
int nI;
for (nI = 0; nI < 5; nI++)
cout<<nArray[nI]<<' ';
cout<<endl;
Index(1) = 9;
for (nI = 0; nI < 5; nI++)
cout<<nArray[nI]<<' ';
return 0;
}
3、下面程序的运行结果为 x=0,y=0
x=2,y=3 。
#include <iostream>
using namespace std;
class Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
void disp()
{
cout<<"x="<<x<<",y="<<y<<endl;
}
};
int main()
{
Sample s1, s2(2,3);
s1.disp();
s2.disp();
return 0;
}
4、下面程序的运行结果为 Constructing account Tom
Constructing account Marry
Constructing account Jerry
Destructing account Tom
Destructing account Jerry
Destructing account Marry 。
#include<iostream>
#include<string.h>
using namespace std;
class Account {
public:
Account(char*, unsigned , double=0.0);
~Account();
private:
char *name;
unsigned acctNumber;
double balance; };
Account::Account(char *pName,unsigned number, double bln)
{
name = new char[strlen(pName)+1];
strcpy(name, pName);
acctNumber=number;
balance=bln;
cout<<"Constructing account "<<name<<endl; }
Account::~Account()
{
cout<<"Destructing account "<<name<<endl;
delete [] name; }
int main()
{
Account *pAcct=new Account("Tom",17);
Account Acct1("Marry",18,200), Acct2("Jerry", 19);
delete pAcct;
return 0;
}
5、下面程序的运行结果为 A=2,B=7
A=5,B=7 。
#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;
int main()
{
Sample s1(2),s2(5);
Sample::func(s1);
Sample::func(s2);
return 0;
}
6、下面程序的运行结果为 class Base
class Base
class Base
class Derived1
class Derived2 。
#include <iostream>
using namespace std;
class Base
{
public:
void Who( ){cout<<"class Base"<<endl;}
};
class Derived1:public Base
{
public:
void Who( ){cout<<"class Derived1"<<endl;}
};
class Derived2:public Base
{
public:
void Who( ){cout<<"class Derived2"<<endl;}
};
int main( )
{
Base obj1,*p;
Derived1 obj2;
Derived2 obj3;
p=&obj1;
p->Who();
p=&obj2;
p->Who();
p=&obj3;
p->Who();
obj2.Who();
obj3.Who();
return 0;
}
7、下面程序的运行结果为 Shape
area:314
Shape
area:15 。
#include<iostream>
using namespace std;
class Shape
{
public:
void Draw()
{
cout<<"Shape"<<endl;
}
virtual void Print()=0;
};
class Circle:public Shape
{
private:
double r;
public:
void Draw()
{
cout<<"Circle"<<endl;
}
void SetData(double radius)
{
r=radius;
}
void Print()
{
cout<<"area:"<<3.14*r*r<<endl;
}
};
class Rectangle:public Shape
{
private:
double a,b;
public:
void Draw()
{
cout<<"Rectangle"<<endl;
}
void SetData(double x,double y)
{
a=x,b=y;
}
void Print()
{
cout<<"area:"<<a*b<<endl;
}
};
int main()
{
Circle c;
Rectangle r;
Shape *sp1=&c;
Shape &sp2=r;
c.SetData(10);
r.SetData(3,5);
sp1->Draw();
c.Print();
sp2.Draw();
r.Print();
return 0;
}
8、下面程序的运行结果为 A::A() called.
B::B() called.
B::~B() called.
A::~A() called. 。
#include<iostream>
using namespace std;
class A
{
public:
A() { cout<<"A::A() called.\n"; }
virtual ~A() { cout<<"A::~A() called.\n"; }
};
class B:public A
{
public:
B(int i)
{
cout<<"B::B() called.\n";
buffer=new char;
}
virtual ~B()
{
delete []buffer;
cout<<"B::~B() called.\n";
}
private:
char* buffer;
};
void fun(A* a) { delete a; }
int main()
{
A *b=new B(10);
fun(b);
return 0;
}
9、下面程序的运行结果为 n=10
n=30 。
#include <iostream>
using namespace std;
class Sample;
Sample operator-(Sample &,Sample &);
Sample operator+(Sample &,Sample &);
class Sample
{
public:
Sample(){}
Sample(int i){n=i;}
friend Sample operator-(Sample &,Sample &);
friend Sample operator+(Sample &,Sample &);
void disp(){cout<<"n="<<n<<endl;}
private:
int n;
};
Sample operator-(Sample &s1,Sample &s2)
{
int m=s1.n-s2.n;
return Sample(m);
}
Sample operator+(Sample &s1,Sample &s2)
{
int m=s1.n+s2.n;
return Sample(m);
}
int main( )
{
Sample s1(10),s2(20),s3;
s3=s2-s1;
s3.disp();
s3=s2+s1;
s3.disp();
return 0;
}
10、下面程序的运行结果为 空行
Index out of range.
Index out of range.
Nankai
Index out of range.U
Index out of range.U
6 。
#include <iostream>
using namespace std;
class CArray
{
public:
CArray(int i)
{
Length=i;
Buffer=new char[Length+1];
}
~CArray() { delete []Buffer; }
int GetLength() { return Length; }
char& operator[](int i);
private:
int Length;
char* Buffer;
};
char& CArray: perator[](int i)
{
static char ch;
if(i<Length&&i>=0)
return Buffer;
else
{
cout<<"\nIndex out of range.";
return ch;
}
}
int main()
{
int cnt;
CArray string1(6);
char *string2="Nankai University";
for(cnt=0;cnt<8;cnt++)
string1[cnt]=string2[cnt];
cout<<endl;
for(cnt=0;cnt<8;cnt++)
cout<<string1[cnt];
cout<<"\n";
cout<<string1.GetLength()<<endl;
return 0;
}
11、下面程序的运行结果为 n=4
n=3 。
#include <iostream>
using namespace std;
class Sample
{
public:
Sample(int i){n=i;}
operator++(){n++;}
operator++(int){n+=2;}
void disp()
{
cout<<"n="<<n<<endl;
}
private:
int n;
};
int main()
{
Sample A(2),B(2);
A++;
++B;
A.disp();
B.disp();
return 0;
}
12、下面程序的运行结果为 i+j=186 。
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ofstream file1;
file1.open("f1.dat");
file1<<123<<endl;
file1<<63.78;
file1.close();
ifstream file2("f1.dat");
int i, j;
file2>>i>>j;
cout<<"i+j="<<i+j<<endl;
file2.close();
return 0;
}
13、下面程序的运行结果为 fg
23456a 。
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
fstream file;
file.open("f1.dat", ios::in | ios:ut);
if(! file)
{
cout<<"f1.dat can't open.\n";
abort();
}
char str[]="abcdefg\n23456";
for(int i=0; i<sizeof(str); i++)
file.put(str);
file.seekg(5);
char ch;
while(file.get(ch))
cout<<ch;
cout<<endl;
file.close();
return 0;
}
14、下面程序的运行结果为 max函数被调用！
red 。
#include <iostream>
#include <string.h>
using namespace std;
template <class T> T max(T a, T b)
{
cout<<"函数模板被使用！"<<endl;
return a>b ? a : b;
}
char *max(char *a, char *b)
{
cout<<"max函数被调用！"<<endl;
return strcmp(a,b)>0 ? a : b;
}
int main()
{
cout<<max("red", "green")<<endl;
return 0;
}
15、下面程序的运行结果为 s1=185
s2=36.5 。
#include <iostream>
using namespace std;
template <class T>
class add
{
T x, y;
public:
add(T a, T b)
{
x=a;
y=b;
}
T add1() { return x+y; }
};
int main()
{
add <int> A(65, 120);
add <double> B(13.6, 22.9);
cout<<"s1="<<A.add1()<<endl;
cout<<"s2="<<B.add1()<<endl;
return 0;
}
二、程序填空
1、swap()函数利用引用作为参数实现两个变量的交换，将程序填写完整。
#include <iostream>
using namespace std;
void swap( int &x, int &y )
{
int temp;
temp=x;
x=y ;
y=temp;
}
int main()
{
int a,b;
cin>>a>>b;
swap( a, b );
cout<<a<<" "<<b<<endl;
return 0;
}
2、下面的程序定义了两个类，一个是TennisClub，其成员数据有俱乐部和会员名，另一个是Person，其成员数据有姓名和年龄，类TennisClub的成员函数visit可以显示姓名、年龄、俱乐部名、会员名。将程序填写完整。
#include <iostream>
#include <string.h>
using namespace std;
class Person ;
class TennisClub
{
public:
TennisClub(char *p,char *q)
{
strcpy(club,p);
strcpy(name,q);
}
void visit(Person);
private:
char club[24];
char name[24];
};
class Person
{
public:
Person(char *p,int y)
{
strcpy(name,p);
age=y;
}
friend void TennisClub::visit(Person x);
private:
char name[24];
int age;
};
void TennisClub::visit(Person x)
{
cout<<"姓名:"<<x.name<<endl;
cout<<"年龄:"<<x.age<<endl;
cout<<"可以使用的俱乐部:"<<club<<endl;
cout<<"介绍人:"<<name<<endl;
}
int main()
{
TennisClub a("明星俱乐部","李晓明");
Person b("张静",28);
a.visit(b);
return 0;
}
3、请将下面程序补充完整。
#include <iostream>
using namespace std;
class Student ;
class Teacher {
public:
void setScore(Student& s,double sc);
void setHour(Student& s,int h);
private:
long number;
char name[10]; };
class Student
{
public:
friend class Teacher ;
double getScore() { return score; }
int getHour() { return semeHour; }
private:
long number;
char name[10];
double score;
int semeHour;
};
void Teacher::setScore(Student& s,double sc) {
s.score=sc; } // 可以直接访问Student的私有数据成员
void Teacher::setHour(Student& s,int h) {
s.semeHour=h; } // 可以直接访问Student的私有数据成员
int main() {
Teacher t;
Student s;
t.setScore(s,98.5);
t.setHour(s,5);
cout<<s.getScore()<<" "<<s.getHour()<<endl;
return 0; }
4、请补充完整下面类说明中的拷贝构造函数。
class MyClass
{
public:
int *p;
int size;
MyClass(int n):size(n),p(new int[n]){}
~MyClass(){delete []p;}
MyClass(MyClass& mc): size( mc.size )
{
p = new int[size] ;
for(int i=0;i<size;i++)
p = mc.p;
}
};
5、将下列程序填写完整。
#include <iostream>
using namespace std;
class Point
{
public:
Point(double a,double b,double c){ X=a;Y=b;Z=c; }
double Getx(){return X;}
double Gety(){return Y;}
double Getz(){return Z;}
private:
double X,Y ;
protected:
double Z ;
};
class Line : public Point
{
public:
Line(double a ,double b,double c,double d)  oint(a,b,c) { K=d; }
void show()
{
cout<<Getx()<<endl;
cout<<Gety()<<endl;
cout<<Getz()<<" "<<Z<<endl;
cout<<K<<endl;
}
private:
double K;
};
int main( )
{
Line obj(1.2,3.4,5.6,7.8);
obj.show();
return 0;
}
6、将下列程序填写完整。
#include <iostream>
using namespace std;
class Furniture
{
public:
void SetWeight(int i){ m_weight =i; }
int GetWeight(){ return m_weight; }
void Move(int i){ cout<<"Move "<<i<<"m."<<endl; }
protected:
int m_weight;
};
class Bed : virtual public Furniture
{
public:
void Sleep(){ cout <<"Sleeping...\n"; }
};
class Sofa : virtual public Furniture
{
public:
void WatchTV(){ cout <<"Watching TV.\n"; }
};
class SofaBed : public Bed, public Sofa
{
public:
void FoldOut(){ cout <<"Fold out the sofa.\n"; }
};
int main()
{
SofaBed ss;
ss.SetWeight(20);
cout <<ss.GetWeight() <<endl;
ss.Move(1);
return 0;
}
7、下面的程序将一个普通函数作为类的友元函数，求坐标点之和，并且程序输出结果为2,2,4，请将程序补充完整。
#include <iostream>
using namespace std;
class Point
{
int X,Y;
public:
Point(int x=0, int y=0)
{ X=x; Y=y; Countp++; }
Point(Point &p)
{ X=p.X; Y=p.Y; Countp++; }
~Point()
{ Countp--; }
friend Point myfun(Point p1, Point p2, Point p3) ;
static int Countp;
void display(){cout<<X<<","<<Y<<",";}
};
Point myfun(Point p1, Point p2, Point p3)
{
Point tmp(p1.X+p2.X+p3.X, p1.Y+p2.Y+p3.Y);
return tmp;
}
int Point::Countp = 0;
int main()
{
Point pp0,pp1(1,2),pp2(1);
Point p=myfun(pp0,pp1,pp2);
p.display ();
cout<< p.Countp或Point::Countp <<endl; // 输出Countp的值
return 0;
}
8、ARRAY类的定义如下，构造函数把参数n的值赋给s，给v动态分配长度为n的数组空间，然后利用数组参数a初始化v所指向的数组。请将类定义补充完整。
class ARRAY
{
int *v;
int s;
public:
ARRAY( int a[], int n );
~ARRAY( )
{ delete []v; }
int size()
{ return s; }
int& operator[](int n);
};
ARRAY:: ARRAY(int a[], int n)
{
if( n<=0 )
{ v=NULL; s=0; return; }
s=n;
v= new int ;
for(int i=0; i<n; i++)
v=a ;
}
9、下面程序的功能是将文本文件readme.txt中的内容读出并显示在屏幕上，请将程序补充完整。
#include <iostream>
#include <fstream>
#include <stdlib.h>
using namespace std;
int main()
{
char str[80];
ifstream me("readme.txt");
if ( !me )
{
cout<<"文件打开失败！"<<endl;
abort();
}
while ( !me.eof() )
{
me. getline (str, 80);
cout<< str <<endl;
}
me.close();
return 0;
}
10、下面程序的功能是：在文件f7.txt的尾部写入一个字符串，请将程序补充完整。
#include <fstream>
#include <string.h>
using namespace std;
int main()
{
char ch[]="The end";
ofstream outstr("f7.txt", ios::app );
for(int i=0; i<strlen(ch); i++)
outstr. put(ch) ;
outstr.close();
return 0;
}
11、下面程序的功能是：统计文件f7.txt中的字符个数，请将程序补充完整。
#include <iostream>
#include <fstream>
#include <stdlib.h>
using namespace std;
int main()
{
fstream file;
file.open("f7.txt", ios::in );
if(!file)
{
cout<<"Can not open f7.txt"<<endl;
abort();
}
char ch;
int i=0;
while (!file.eof())
{
file.get( ch );
i++;
}
cout<<"Characters: "<<i<<endl;
file.close();
return 0;
}
12、下面的程序将一个已有文件的内容复制到另一个文件中。请将程序补充完整。
#include<iostream>
#include<fstream>
#include<stdlib.h>
using namespace std;
int main()
{
fstream infile, outfile ;
infile.open("c:\\file1.txt",ios::in);
if (!infile)
{
cout<<"file1.txt can't open.\n";
abort();
}
outfile.open("c:\\file2.txt",ios:ut);
if(!outfile)
{
cout<<"file2.txt can't open.\n";
abort();
}
char str[80]="\0";
while(!infile.eof())
{
infile.read(str,sizeof(str));
outfile.write(str, sizeof(str)) ;
cout<<str;
}
cout<<endl;
infile.close();
outfile.close() ;
return 0;
}
13、下面的程序是一个类模板，可实现求三个变量的和，请将程序补充完整。
#include <iostream>
using namespace std;
template <class Type>
class ff
{
Type a1, a2, a3;
public:
ff(Type b1, Type b2, Type b3)
{ a1=b1; a2=b2; a3=b3; }
Type sum()
{ return a1+a2+a3; }
};
int main()
{
ff <int> x(12,13,14), y(16,17,18);
cout<<x.sum()<<" "<<y.sum()<<endl;
return 0;
}
三、单项选择题
1、结构化程序设计方法以（ B ）为中心进行分析和设计。
A、结构 B、模块 C、对象 D、类
2、面向对象程序设计方法以（ C ）为中心进行分析和设计。
A、结构 B、模块 C、对象 D、类
3、“#include <iostream>”是（ B ）预处理命令。
A、宏定义 B、文件包含 C、条件编译 D、工程配置
4、下列关于主函数的叙述中正确的是（ B ）。
A、一个程序可以有多个主函数
B、程序从主函数开始执行
C、一个程序可以没有主函数
D、主函数是一个特殊的函数，因此其结构与其他函数不同
5、在一个C++源文件中使用了cin和cout，那么在这个源文件中必须包含（ A ）文件。
A、iostream B、fstream C、stdio.h D、stdlib.h
6、已知函数原型：void f(int a, int b=3,char c='*'); 则下面的函数调用中，不合法的调用是（ C ）。
A、f(5) B、f(5,8) C、f(6, , '#') D、f(0,0, '#')
7、程序在调用重载函数时，根据（ C ）区分到底要调用哪个函数。
A、函数名 B、返回值类型
C、参数个数和类型 D、以上都可以
8、变量的引用，其含义是指该变量的（ C ）。
A、值 B、类型 C、别名 D、地址
9、已知“float *p; p=new float[2];”，若要释放p所指向的堆中的这些字节，下列语句正确的是（ C ）。
A、delete p; B、delete p[]; C、delete []p; D、delete p[2];
10、已知“int a=10,b=8;int &r=a; r=b;cout<<a<<","<<b<<","<<r;”，则输出为（ D ）。
A、10,8,10 B、10,8,8 C、8,8,10 D、8,8,8
11、假设堆内存分配均成功，则下面程序段完全正确的是（ A ）。
A、int *p=new int(3);cout<<*p;delete p;
B、int *p=new int[5]={1,2,3,4,5};for(int i=0;i<5;i++)cout<<p;delete []p;
C、int *p=new int[5];for(int i=0;i<5;i++,p++) {*p=i; cout<<*p;}delete []p;
D、以上程序段均正确
12、有关带默认参数的函数的描述正确的是（ D ）。
A、只能在函数定义时设置默认参数值
B、只能在函数声明时设置默认参数值
C、函数调用时，必须使用默认的参数值，不能给出新的实参值
D、设置默认参数时，应该设置最右边的若干个参数的默认值
13、有关重载函数的描述正确的是（ C ）。
A、函数名相同的函数就是重载函数
B、函数名相同但返回值类型不同的函数就是重载函数
C、函数名相同但参数个数或类型不同的函数就是重载函数
D、函数功能相同的函数就是重载函数
14、以下为重载函数的一组函数声明的是（ A ）。
A、void print(int); void print(double);
B、void fun(int); int fun(int);
C、int max(int,int); int min(int,int);
D、void mm(); int mm();
15、已知“int a=10;int &r=a; r=r+20;cout<<a;”，则输出为（ C ）。
A、10 B、20 C、30 D、不确定值
16、已知“int a=10,*p;int *&r=p; r=&a;*r=20;cout<<a;”，则输出为（ B ）。
A、10 B、20 C、不确定值 D、程序有错误
17、下列关于类和对象的叙述中，错误的是（ A ）。
A、一个类只能有一个对象 B、对象是类的具体实例
C、类是某一类对象的抽象 D、类和对象的关系是一种数据类型与变量的关系
18、有如下类声明：
class Sample { int x; };
则Sample类成员x是Sample类的（ C ）。
A、公有数据成员 B、保护数据成员
C、私有数据成员 D、以上选项都不正确
19、下列关于成员函数特征的描述中，错误的是（ B ）。
A、成员函数可以重载
B、成员函数一定是内联函数
C、成员函数可以设置参数的默认值
D、成员函数可以是静态的
20、类的默认的无参构造函数（ D ）。
A、在任何情况下都存在
B、仅当未定义无参构造函数时存在
C、仅当未定义有参构造函数时存在
D、仅当未定义任何构造函数时存在
21、C++中，关于构造函数和析构函数，正确的描述是（ C ）。
A、在定义类时，必须自定义构造函数和析构函数，在创建对象时自动调用构造函数，在释放对象时自动调用析构函数
B、构造函数和析构函数均可以重载
C、已知类Student以及Student *p; 在使用p=new Student;时自动调用无参构造函数创建动态对象，在delelte p;时自动调用析构函数释放动态对象
D、构造函数和析构函数都可以成为虚函数
22、通常的拷贝构造函数的参数是（ C ）。
A、某个对象名 B、某个对象的成员名
C、某个对象的引用名 D、某个对象的指针名
23、任意一个类，析构函数的个数最多是（ B ）。
A、不限个数 B、1 C、2 D、3
24、对于拷贝构造函数，正确的描述是（ A ）。
A、在C++语言中，如果不自定义类的拷贝构造函数，则每个类都有默认的拷贝构造函数
B、必须为每个类定义拷贝构造函数
C、如果要使用拷贝构造函数，则必须在类中先定义
D、当定义了类的构造函数时，如果要使用拷贝构造函数，则必须定义拷贝构造函数
25、在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是（ C ）。
A、友元函数 B、虚函数 C、构造函数 D、析构函数
26、静态数据成员初始化在（ B ）进行，而且前面不加static，以免与一般静态变量或对象相混淆。
A、类体内 B、类体外 C、构造函数内 D、内联函数内
27、有关静态成员的描述错误的是（ D ）。
A、某个类的静态数据成员由该类的所有对象所共享
B、类的公有静态数据成员既可以用类的对象访问，也可以直接用作用域运算符“::”通过类名来访问
C、静态数据成员既可以是私有成员，也可以是公有成员
D、类中一旦定义了静态数据成员，就必须定义静态成员函数，以便对静态数据成员进行操作
28、如果类A被说明成类B的友元，则（ B ）。
A、类A的成员函数不得访问类B的所有成员
B、类A的成员函数可以访问类B的所有成员
C、类A的成员即类B的成员
D、类B的成员即类A的成员
29、下列关于this指针的说法，正确的是（ D ）。
A、this指针一定指向常量型数据
B、this指向的数据不可更改
C、静态成员函数中也可以访问this指针
D、this指针本身可直接作为成员函数的返回值
30、使用string类，必须在程序中包含头文件（ B ）。
A、string.h B、string C、cstring.h D、cstring
31、在一个string类对象表示的字符串中插入新字符，应该使用string类的（ B ）函数。
A、assign B、insert C、swap D、find
32、将一个string类对象赋予新值，应该使用string类的（ A ）函数。
A、assign B、insert C、swap D、find
33、在C++中，通过（ A ）的机制可以扩充和完善旧的程序设计以适应新的需要。
A、继承 B、封装 C、多态 D、重载
34、下列关于继承的描述中，错误的是（ D ）。
A、析构函数不能被重载
B、派生类是基类的组合
C、派生类的成员除了它自己的成员外，还包括了它的基类成员
D、派生类中基类成员的访问权限到派生类保持不变
35、派生类中的成员不能访问基类中的（ A ）。
A、私有成员 B、公有成员 C、保护成员 D、以上都可以
36、下面描述中，错误的是（ B ）。
A、公有继承时，基类中的public成员在派生类中仍是public的
B、公有继承时，基类中的private成员在派生类中仍是private的
C、公有继承时，基类中的protected成员在派生类中仍是protected的
D、私有继承时，基类中的public成员在派生类中是private的
37、派生类的构造函数的成员初始化列表中，不能包含（ C ）。
A、基类的构造函数 B、派生类中子对象的初始化
C、基类的子对象初始化 D、派生类中一般数据成员的初始化
38、基类的（ B ）在私有继承时在派生类中为私有成员函数，在公有和保护继承时在派生类中为保护成员函数。
A、私有成员函数 B、保护成员函数
C、公有成员 D、保护数据成员
39、多继承的构造函数顺序可分为如下4步：
①所有非虚基类的构造函数按照它们被继承的顺序构造。
②所有虚基类的构造函数按照它们被继承的顺序构造。
③所有子对象的构造函数按照它们声明的顺序构造。
④派生类自己的构造函数体
这四个步骤的正确顺序是（ C ）。
A、④③①② B、②④③① C、②①③④ D、③④①②
40、下列关于虚函数的说明中，正确的是（ B ）。
A、从虚基类继承的函数都是虚函数
B、虚函数不得是静态成员函数
C、只能通过指针或引用调用虚函数
D、抽象类中的成员函数都是虚函数
41、虚函数必须是类的（ B ）。
A、友元函数 B、成员函数 C、构造函数 D、析构函数
42、对于虚析构函数与一般虚函数，以下说法正确的是（ C ）。
A、重定义函数就是派生类的构造函数
B、重定义函数就是派生类的析构函数，要求同名
C、一个虚析构函数的版本被调用执行后，接着就要执行其基类版本
D、基类和派生类都分别给出了一个虚函数的不同版本
43、类型兼容是指在基类对象可以出现的地方，都可以使用公有派生类的对象，已知：
class BaseClass
{ //…};
class DerivedClass:public BaseClass
{ //…};
BaseClass b,*pb;
DerivedClass d,*pd;
下面不属于类型兼容的是（ C ）。
A、b=d; B、BaseClass &bb=d;
C、pd=&b; D、pb=&d;
44、抽象类的作用主要是（ D ）。
A、直接用作基类 B、直接用作指针
C、引用的基类型 D、包括以上各项
45、抽象类不能定义对象，但可以声明抽象类的（ D ）。
A、指针或引用 B、函数返回类型
C、显式转换 D、以上都是
46、在一个类中，可以对一个操作符进行（ D ）重载。
A、1种 B、2种 C、3种 D、多种
47、下列运算符中，（ A ）在C++中不能重载。
A、?: B、+ C、- D、<=
48、在表达式x+y*z中，+ 是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（ C ）。
A、operator+有两个参数，operator*有两个参数
B、operator+有两个参数，operator*有一个参数
C、operator+有一个参数，operator*有两个参数
D、operator+有一个参数，operator*有一个参数
49、友元重载运算符obj1>obj2被C++编译器解释为（ A ）。
A、operator>(obj1,obj2) B、>(obj1,obj2)
C、obj1.operator>(obj2) D、obj2.operator>(obj1)
50、下列运算符中，必须使用成员函数进行重载的是（ B ）。
A、== B、= C、>> D、++
51、下列关于运算符重载的描述中，错误的是（ D ）。
A 、运算符重载不可以改变优先级
B、运算符重载不可以改变结合性
C、运算符重载不可以改变运算符的操作数个数
D、加法运算符“+”和赋值运算符“=”都重载之后，意味着“+=”也被重载了
52、有关运算符重载的说法错误的是（ C ）。
A、在一个类中，可以对一个操作符进行多次重载
B、重载赋值运算符“=”时，为了保持原有特性，重载运算符函数中应该使用返回语句“return *this;”
C、C++中所有的运算符都可以被重载
D、如果在某个类中使用成员函数对运算符重载，其左操作数必须是该类的对象
53、已知某个类的友元函数重载了+=和-，a，b，c是该类的对象，则“a+=b-c”被C++编译器解释为（ A ）。
A、operator+=(a,operator-(b,c)) B、a.operator+=(b.operator-(c))
C、operator+=(a,b.operator-(c)) D、a.operator+=(operator-(b,c))
54、cout是I/O流库预定义的（ B ）。
A、类 B、对象 C、常量 D、包含文件
55、4个预定义流对象为带缓冲的标准出错信息输出的是（ D ）。
A、cin B、cout C、cerr D、clog
56、下面4个选项中，表示读取单个字符的是（ B ）。
A、cin B、cin.get() C、cin.put() D、cin.getline()
57、cin是（ A ）类的一个对象，用来处理标准输入，即键盘输入。
A、istream B、ostream C、fstream D、iostream
58、在C++中，打开一个文件，就是将该文件与（ B ）建立关联；关闭一个文件，就是取消这种关联。
A、类 B、流对象 C、对象 D、结构
59、C++程序进行文件操作时，需要包含头文件（ B ）。
A、iostream B、fstream C、stdio.h D、stdlib.h
60、下列关于read( )函数的叙述中，正确的是（ D ）。
A、read( )函数只能从键盘输入中获取字符串
B、read( )函数所获取的字符多少是不受限制的
C、read( )函数只能用于对文本文件的操作
D、read( )函数只能按规定读取所指定的字符数
61、下列关于getline( )函数的叙述中，错误的是（ D ）。
A、getline( )函数可以用于从键盘上读取字符串
B、getline( )函数读取字符串长度是受限制的
C、getline( )函数读取字符串时，遇到终止符就停止
D、getline( )函数中所使用的终止符只能是换行符
62、以下叙述中，错误的是（ D ）。
A、C++语言中的文本文件以ASCII 码形式存储数据
B、C++语言中对二进制文件的访问速度比文本文件快
C、用open( )函数打开的文件，使用完毕后，必须用close()函数关闭
D、C++语言中，随机读/写方式不适用于文本文件
63、以下选项中，错误的是（ C ）。
A、fstream iofile; iofile.open("abc.txt", ios::in);
B、ofstream ofile; ofile.open("C:\\vc\\abc.txt", ios::binary);
C、cout.open("C:\\vc\\abc.txt", ios::binary);
D、ifstream ifile("C:\\vc\\abc.txt");
64、（ C ）使一个函数可以定义成对不同数据类型完成相同操作。
A、重载函数 B、模板函数 C、函数模板 D、递归函数
65、函数模板的执行代码是在（ D ）时生成的。
A、执行函数 B、源程序中声明函数
C、源程序中定义函数 D、源程序中调用函数
66、下面函数模板的定义中，有（ B ）处错误。
template <class T1, T2>
T2 f1(T1 a, T1 b)
{
return (a>b) ? (a) : (b);
}
A、1 B、2 C、3 D、4
67、一个（ C ）允许用户为类定义一种模式，使得类中的某些数据成员及某些成员函数的返回值能取任意类型。
A、函数模板 B、模板函数 C、类模板 D、模板类
68、类模板的模板参数（ D ）。
A、只可作为数据成员的类型 B、只可作为成员的返回类型
C、只可作为成员函数的参数类型 D、以上3项均可以
四、判断题
1、在C++程序中，主函数的函数名必须是main。 （√）
2、类中所提供的成员函数可以直接访问该类的私有成员。 （√）
3、类定义中的成员默认的访问权限是private。 （√）
4、一个类中的保护成员和公有成员类似，在程序的任何地方都可以被访问。 （×）
5、系统提供的缺省构造函数没有参数，所以自定义构造函数必须带有参数。 （×）
6、一旦自定义了构造函数，系统便不再提供缺省的构造函数。 （√）
7、一个类只能有一个构造函数和一个析构函数。 （×）
8、静态数据成员必须在类中进行定义和初始化。 （×）
9、静态成员函数中不能访问非静态成员。 （√）
10、在一个类中声明了某个静态数据成员，并在类外给出其定义和初始化后，若未定义该类的对象，该静态数据成员则不存在。 （×）
11、派生类至少有一个基类。 （√）
12、在C++中，允许从一个类派生出任意多个类，但不允许某个类同时从多个类派生。（×）
13、对虚函数的调用，系统都是采用动态联编。 （×）
14、抽象类虽然也是一种数据类型，但它不能建立对象，只能作为基类被其他类继承。（√）
15、重载插入运算符“<<”必须采用成员重载。 （×）
16、如果类A是类B的友类，那么类A中的所有成员函数都可以访问类B中的所有成员。 （√）
17、释放派生类的对象时，首先调用基类的析构函数，然后调用派生类的析构函数。 （×）
18、拥有纯虚函数的类称为虚拟基类，它不能用来定义对象。 （√）
19、虚函数只有在有继承的情况时才会存在。 （√）
20、已知：class Base1{//…};
class Base2{//…};
class Derived:public Base1, public Base2
{ Derived():Base2(),Base1(){}
//…
};
创建Derived类的对象时，先调用Base2的构造函数，然后调用Base1的构造函数，最后调用Derived的构造函数。 （×）
21、基类的指针或引用调用虚函数时采用后期绑定。 （√）
22、由抽象基类继承得到的派生类肯定是具体类。 （×）
23、友元函数内能够访问任何对象的任何成员。 （×）
24、对二元运算符采用成员函数重载时，只需要一个参数，而且该参数可以是内部类型。 （√）
25、对一元运算符采用某个类的友元函数重载时需要一个参数，参数为该类的对象，不能是其他类型。 （√）
26、C++的输入/输出流库中，ios类是一个虚基类，istream类、ostream类以及streambuf类都是ios类的派生类。 （×）
27、设inf是一个ifstream类的流对象，则inf.seekg(10,ios::beg);表示将文件指针从文件当前位置向后移动10个字节。 （×）
五、填空题
1、C++源程序文件的扩展名为 cpp 。
2、已知定义函数：void f (char ch='*'){cout<<ch;}
在主函数中有调用语句“f ('# ');”，则输出为 # 。
3、 构造函数 是个特殊成员函数，用于初始化类的数据成员。
4、在C++语言中，每个类都有一个隐含的指针，叫做 this 指针。该指针指向 正在操作的对象 。
5、有如下定义语句：MyClass *p；，则执行p=new MyClass；语句时，将自动调用该类的 构造函数 。执行delete p；语句时，将自动调用该类的 析构函数 。
6、 继承方式 用于控制基类中声明的成员在多大的范围内能被派生类的用户访问。
7、派生类除了从基类继承所有成员之外，通常还增加了新的 数据成员 和 成员函数 。
8、派生类从基类 公有继承 时，基类的公有成员和保护成员在派生类中仍然是公有成员和保护成员。
9、对基类成员的初始化必须在派生类 构造 函数的成员初始化列表中调用基类构造函数完成。
10、继承方式有三种： 公有继承 、 保护继承 和 私有继承 。
11、拥有纯虚函数的类称为 抽象类 ，它不能用来定义对象。
12、在派生类中可以重新定义从基类继承下来的虚函数。重定义时，通常要保持 函数名 、 形参列表 和 返回类型 不变。
13、在成员函数专用名的前面加上 virtual 修饰，即把该函数声明为虚函数。
14、抽象类区别于其他类的最根本特征是 包含纯虚函数、不能实例化对象 。
15、虚函数不得声明为 静态函数 。
16、抽象类中的纯虚函数的实现由 派生类 给出。
17、重载运算符函数的函数名由关键字 operator 引出。
18、运算符的重载归根结底是 函数 的重载。
19、后缀自增自减运算符定义时带有 整型形参 。
20、重载的运算符的参数不能全部是 内部类型 。
21、 编译程序选择重载的运算符是遵循 函数重载 的原则
22、编译程序选择重载的运算符按照 形参个数 或 形参类型 来选择不同的重载运算符。
23、cin是 istream类 的一个对象，处理标准输入；cout、cerr和clog是 ostream类 的对象，cout处理标准输出，cerr和clog处理标准出错信息。
24、文件流可分为3类：输入流、输出流和 输入输出流 ，相应地必须将流说明为ifstream、ofstream及fstream类的对象。
25、如果一个函数模板定义有多个类型参数，则每个类型形参之间必须用逗号隔开，并且每个类型形参都必须使用关键字 class 进行说明。
26、已知int fun(int a) {return a*a;}和float fun(float a) {return a*a;}是一个函数模板的两个实例，则该函数模板的定义为 template <class T> T fun(T a) {return a*a;} 。
27、使用函数模板的方法是先定义函数模板，然后实例化成相应的 模板函数 进行调用执行。
转载请注明奥鹏作业答案网www.ap5u.com
|
|
