南开12春《面向对象程序设计》课程复习大纲与练习题
《面向对象程序设计》课程复习大纲与练习题课程名称 面向对象程序设计
教
材
信
息 名称 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;
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;
}
int main()
{
int nI;
for (nI = 0; nI < 5; nI++)
cout<<nArray<<' ';
cout<<endl;
Index(1) = 9;
for (nI = 0; nI < 5; nI++)
cout<<nArray<<' ';
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;
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;
}
~CArray() {delete []Buffer;}
int GetLength() {return Length;}
char& operator[](int i);
private:
int Length;
char* Buffer;
};
char& CArray::operator[](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=string2;
cout<<endl;
for(cnt=0;cnt<8;cnt++)
cout<<string1;
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::out);
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;
char name;
};
class Person
{
public:
Person(char *p,int y)
{
strcpy(name,p);
age=y;
}
friend void TennisClub::visit(Person x);
private:
char name;
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; };
class Student
{
public:
friend class Teacher;
double getScore() { return score; }
int getHour() { return semeHour; }
private:
long number;
char name;
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){}
~MyClass(){delete []p;}
MyClass(MyClass& mc): size(mc.size)
{
p = new int;
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):Point(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;
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::out);
if(!outfile)
{
cout<<"file2.txt can't open.\n";
abort();
}
char str="\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、iostreamB、fstreamC、stdio.hD、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;”，若要释放p所指向的堆中的这些字节，下列语句正确的是（C）。
A、delete p;B、delete p[];C、delete []p;D、delete p;
10、已知“int a=10,b=8;int &r=a; r=b;cout<<a<<","<<b<<","<<r;”，则输出为（D）。
A、10,8,10B、10,8,8C、8,8,10D、8,8,8
11、假设堆内存分配均成功，则下面程序段完全正确的是（A）。
A、int *p=new int(3);cout<<*p;delete p;
B、int *p=new int={1,2,3,4,5};for(int i=0;i<5;i++)cout<<p;delete []p;
C、int *p=new int;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.hB、string C、cstring.hD、cstring
31、在一个string类对象表示的字符串中插入新字符，应该使用string类的（B）函数。
A、assignB、insert C、swap D、find
32、将一个string类对象赋予新值，应该使用string类的（A）函数。
A、assignB、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、istreamB、ostreamC、fstreamD、iostream
58、在C++中，打开一个文件，就是将该文件与（B）建立关联；关闭一个文件，就是取消这种关联。
A、类 B、流对象C、对象 D、结构
59、C++程序进行文件操作时，需要包含头文件（B）。
A、iostreamB、fstreamC、stdio.hD、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
页:
[1]