南开15春《面向对象程序设计》期末复习资料

谋学网 · 发表于 2015-9-10 10:35:12

《面向对象程序设计》复习资料

一、客观部分：（单项选择、多项选择、不定项选择、判断）
（一）、选择部分
1、面向对象程序设计方法以（  C  ）为中心进行分析和设计。
A、结构 B、模块 C、对象 D、类
★考核知识点: 程序设计的基本概念
附1.1.1（考核知识点解释）：
面向对象程序设计方法以“对象”为中心进行分析和设计，将对象设计成解决目标问题的基本构件，思想是先将问题空间划分为一系列对象的集合，再将具有相同属性和行为的对象抽象成一个类，采用继承机制来建立这些类之间的联系，形成结构层次。面向对象程序设计方法的本质就是不断设计新的类和创建对象的过程。
2、下列关于主函数的叙述中正确的是（  B  ）。
A、一个程序可以有多个主函数
B、程序从主函数开始执行
C、一个程序可以没有主函数
D、主函数是一个特殊的函数，因此其结构与其他函数不同
★考核知识点: C++源程序的组成
附1.1.2（考核知识点解释）
一个C++程序一般由多个函数组成。这些函数可以是用户根据需要编写的自定义函数，也可以是直接使用系统提供的标准库函数。函数体用一对花括号“{”和“}”括起来。任何一个程序必须有且仅有一个主函数main，程序从主函数开始执行。
3、有关带默认参数的函数的描述正确的是（  D  ）。
A、只能在函数定义时设置默认参数值
B、只能在函数声明时设置默认参数值
C、函数调用时，必须使用默认的参数值，不能给出新的实参值
D、设置默认参数时，应该设置最右边的若干个参数的默认值
★考核知识点: 带默认形参值的函数
附1.1.3（考核知识点解释）
在调用函数时，需要针对函数中的每一个形参给出对应的实参。C++中允许在函数定义或函数声明时给出默认的形参值。在调用函数时，对于有默认值的形参，如果没有给出相应的实参，则函数会自动使用默认形参值；如果给出相应的实参，则函数会优先使用传入的实参值。
默认形参值可以在两个位置指定：如果有函数声明，则应在函数声明处指定；否则，直接在函数定义中指定。默认形参值必须严格按照从右至左的顺序进行指定。
4、有关重载函数的描述正确的是（  C  ）。
A、函数名相同的函数就是重载函数
B、函数名相同但返回值类型不同的函数就是重载函数
C、函数名相同但参数个数或类型不同的函数就是重载函数
D、函数功能相同的函数就是重载函数
★考核知识点: 函数重载
附1.1.4（考核知识点解释）
C++允许不同的函数具有相同的函数名，这就是函数重载。当调用一个函数时，除了要写出函数名，还要根据函数的形参列表传递实参值。
对于函数名相同的多个函数，要在调用时能够区分开到底要调用哪个函数，只能根据传递实参在数量或类型上的不同来进行判断。也就是说，函数名相同的函数形参列表不能完全一样，否则会因无法区分而报错。
5、假设堆内存分配均成功，则下面程序段完全正确的是（  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[i];delete []p;
C、int *p=new int[5];for(int i=0;i<5;i++,p++) {*p=i; cout<<*p;}delete []p;
D、以上程序段均正确
★考核知识点: 堆内存分配
附1.1.5（考核知识点解释）
在C++中，使用new和delete这两个关键字完成堆内存分配和释放的操作。
堆内存分配new的用法为：new 数据类型[表达式]; 其中，表达式可以是常量，也可以是变量，其作用与声明数组时[]里的表达式一样，用于指定元素数目。如果只申请一个元素的空间，那么[表达式]部分可以不写： new 数据类型; 对于只申请一个元素空间的情况，在分配内存的同时还可以进行内存初始化工作：new 数据类型(表达式); 其中，表达式确定了分配的内存中初始存储的数据。
堆内存释放delete的用法为：delete []p; 如果p所指向的堆内存只包含一个元素，那么还可以将[]省掉，即：delete p; 必须使用指针保存分配的堆内存首地址，这是由于delete须根据首地址进行堆内存释放，如果不知道首地址则无法释放内存，从而造成内存泄漏。
6、变量的引用，其含义是指该变量的（  C  ）。
A、值 B、类型 C、别名 D、地址
★考核知识点: 引用的概念
附1.1.6（考核知识点解释）
引用就是别名，变量的引用就是变量的别名，对引用的操作就是对所引用变量的操作。
7、已知“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
★考核知识点: 引用的声明与特点
附1.1.7（考核知识点解释）
引用就是一个别名，声明引用不会再为其分配内存空间，而是与所引用对象占据同一片内存空间。因此，对引用的操作与对所有引用对象的操作效果完全一样。
8、已知“int a=10,*p;int *&r=p; r=&a;*p=20;cout<<a;”，则输出为（  B  ）。
A、10 B、20 C、不确定值 D、程序有错误
★考核知识点: 引用的声明与特点
附1.1.8（考核知识点解释）
引用就是一个别名，声明引用不会再为其分配内存空间，而是与所引用对象占据同一片内存空间。因此，对引用的操作与对所有引用对象的操作效果完全一样。
可以为指针变量声明引用，其声明形式为：数据类型 *&引用名=指针变量名;
9、下列关于类和对象的叙述中，错误的是（  A  ）。
A、一个类只能有一个对象 B、对象是类的具体实例
C、类是某一类对象的抽象 D、类和对象的关系是一种数据类型与变量的关系
★考核知识点: 类和对象的基本概念、对象的声明
附1.1.9（考核知识点解释）
类是现实世界中客观事物的抽象，即将具有相似静态属性和动态行为的对象集合归纳为一个类。
类是用户自定义的数据类型，与基本数据类型一样，需要声明类数据类型的变量，即对象，通过对一个个的实际对象实施不同的操作，来解决问题。声明对象的过程叫做类的实例化。
10、有如下类声明：
class Sample { int x; };
则Sample类成员x是Sample类的（  C  ）。
A、公有数据成员 B、保护数据成员
C、私有数据成员 D、以上选项都不正确
★考核知识点: 类成员的访问控制
附1.1.10（考核知识点解释）
类中可以出现多个访问说明符，每个访问说明符可以出现多次，不同的访问说明符出现的顺序没有限制。如果没有指明是哪种访问级别，C++编译系统默认为私有（private）成员。
11、C++中，关于构造函数和析构函数，正确的描述是（  C  ）。
A、在定义类时，必须自定义构造函数和析构函数，在创建对象时自动调用构造函数，在释放对象时自动调用析构函数
B、构造函数和析构函数均可以重载
C、已知类Student以及Student *p; 在使用p=new Student;时自动调用无参构造函数创建动态对象，在delelte p;时自动调用析构函数释放动态对象
D、构造函数和析构函数都可以成为虚函数
★考核知识点: 构造函数和析构函数
附1.1.11（考核知识点解释）
在C++中，对象的初始化工作是由构造函数来完成的。构造函数是一种特殊的成员函数， C++规定可以在类内声明一个或多个构造函数，以满足对象多样性的初始化需要。构造函数具有如下特征：
①构造函数名与类名相同。
②构造函数无任何函数返回类型说明。
③一个新的对象被创建时（通过对象声明语句或使用new运算符在堆区创建动态对象），属于该对象的构造函数被编译系统自动调用，完成该对象数据成员的初始化工作。
④如果在类声明中没有给出构造函数，系统会自动给出一个默认的无参构造函数：
<类名>( ){ }
⑤如果在类中声明了多个构造函数，这就是构造函数的重载。要求这些构造函数要有不同的参数表，系统自动调用构造函数时按照函数重载的规则选择其中的一个构造函数。
在对象的生存期结束时，有时也需要执行一些操作。这些工作就可以放在析构函数中。析构函数是一个特殊的由用户定义的公有成员函数，析构函数具有如下特征：
①析构函数名为：~<类名>，如~IntArray。
②构造函数无任何函数返回类型说明。
③析构函数无参数，所以不能被重载。
④如果在类声明中没有给出析构函数，系统会自动给出一个默认的析构函数：
~<类名>(){}
⑤当对象的生命周期结束及用delete释放动态对象时，系统自动调用析构函数完成对象撤销前的处理。
12、在类的定义中，用于对类的数据成员进行初始化并执行其他内部管理操作的函数是（  C  ）。
A、友元函数 B、虚函数 C、构造函数 D、析构函数
★考核知识点: 构造函数
附1.1.12（考核知识点解释）
一个新的对象被创建时（通过对象声明语句或使用new运算符在堆区创建动态对象），属于该对象的构造函数被编译系统自动调用，完成该对象数据成员的初始化工作。
13、对于拷贝构造函数，正确的描述是（  A  ）。
A、在C++语言中，如果不自定义类的拷贝构造函数，则每个类都有默认的拷贝构造函数
B、必须为每个类定义拷贝构造函数
C、如果要使用拷贝构造函数，则必须在类中先定义
D、当定义了类的构造函数时，如果要使用拷贝构造函数，则必须定义拷贝构造函数
★考核知识点: 拷贝构造函数
附1.1.13（考核知识点解释）
拷贝构造函数有如下特征：
（1）拷贝构造函数名与类名相同，形参只有一个，是对象的引用，所以，不能重载拷贝构造函数。拷贝构造函数的原形为：
<类名>(<类名> &对象名);
（2）拷贝构造函数无任何函数返回类型说明。
（3）如果在类声明中没有给出拷贝构造函数，系统会自动给出一个默认的拷贝构造函数，该拷贝构造函数只进行对象数据成员间的对位拷贝，即所谓的“浅拷贝”。
（4）在某些情况下，用户必须在类定义中给出一个显式的拷贝构造函数，以实现用户指定的用一个对象初始化另一个对象的功能，即所谓的“深拷贝”。
（5）在以下3种情况下，系统会自动调用拷贝构造函数：
①当使用下面的声明语句用一个已存在的对象初始化一个新对象时，系统会自动调用拷贝构造函数：
<类名><新对象名>(<已存在对象名>);
或
<类名><新对象名>=<已存在对象名>;
②对象作为实参，在函数调用开始进行实参和形参结合时，会自动调用拷贝构造函数，完成由已知的实参对象初始化形参新对象的功能。
③如果函数的返回值是类的对象，在函数调用完成返回时，系统自动调用拷贝构造函数，用return后面的已知对象来初始化一个临时新对象（所创建的临时对象只在外部表达式范围内有效，表达式结束时，系统将自动调用析构函数撤销该临时对象）。
14、有关静态成员的描述错误的是（  D  ）。
A、某个类的静态数据成员由该类的所有对象所共享
B、类的公有静态数据成员既可以用类的对象访问，也可以直接用作用域运算符“::”通过类名来访问
C、静态数据成员既可以是私有成员，也可以是公有成员
D、类中一旦定义了静态数据成员，就必须定义静态成员函数，以便对静态数据成员进行操作
★考核知识点: 构造函数
附1.1.14（考核知识点解释）
在类的成员前如果加上关键字static，这种成员就是类的静态成员。类的静态成员包括静态数据成员和静态成员函数。类的静态成员的特点是：静态成员属于类，不属于任何对象。无论有多少对象或没有对象，静态成员都只有一份存于公用内存中，被该类的所有对象共享。
在类定义中的数据成员声明前加上关键字static，就使该数据成员成为静态数据成员。静态数据成员可以是public（公有）、private（私有）或protected（保护）的。在下面定义的Account类中，m_rate被声明为私有静态成员。
在类中声明的静态数据成员属于引用性说明，并不实际分配内存。在创建对象时，会为对象的数据成员分配存储空间。但由于静态数据成员不属于任何对象，所以在创建对象时也不会为该类的静态数据成员分配存储空间。所以，类设计者需要在类外对静态数据成员进行定义。静态数据成员的定义形式如下：
<类型><类名>::<静态数据成员名>[=<初值>];
类的静态数据成员不属于任何类，类的公有静态数据成员的一般访问形式是：
<类名>::<静态数据成员名>
也可以是：
<对象名>.<静态数据成员名>
或
<对象指针>-><静态数据成员名>
后两种访问方式中的“对象名”或“对象指针”只起到类名的作用，与具体对象无关。
如果成员函数被声明为static的，它就是静态成员函数。像静态成员数据一样，静态成员函数与具体对象无关。静态成员函数不能访问一般的数据成员，它只能访问静态数据成员，也只能调用其他的静态成员函数。
对类的静态成员函数的调用形式通常是：
<类名>::<静态成员函数调用>
可以用成员访问操作符点（.）和箭头（->）为一个类对象或指向类对象的指针调用，只是，这时候使用的只是对象的类型，与具体对象无关。
15、如果类A被说明成类B的友元，则（  B  ）。
A、类A的成员函数不得访问类B的所有成员
B、类A的成员函数可以访问类B的所有成员
C、类A的成员即类B的成员
D、类B的成员即类A的成员
★考核知识点: 构造函数
附1.1.15（考核知识点解释）
将一个类声明为另一个类的友类的语法形式为：
friend <友类名>;
或
friend class <友类名>;
将A类声明为B类的友类。声明后，A类的任何成员函数都有权访问B类中的任何成员，包括私有成员和保护成员。
16、下列关于this指针的说法，正确的是（  D  ）。
A、this指针一定指向常量型数据
B、this指向的数据不可更改
C、静态成员函数中也可以访问this指针
D、this指针本身可直接作为成员函数的返回值
★考核知识点: 构造函数
附1.1.16（考核知识点解释）
每个类成员函数都含有一个指向被调用对象的指针，这个指针被称为this指针。this指针是一个隐含于每一个非静态成员函数中的特殊指针，就是成员函数的一个类指针类型的形参。当对一个对象调用非静态成员函数时，编译程序先将该对象的地址传递给成员函数的this指针，以及完成其他的参数传递，然后再进入成员函数内部进行处理。在成员函数内部存取数据成员或调用其他成员函数时，都是通过this指针隐式地引用它所指向的对象的成员数据和成员函数。事实上，也可以通过this指针显式引用它所指向对象的成员数据和成员函数。
由于有了this指针的存在，使得类中相同的成员函数会根据this指针指向对象的不同而操作不同对象的数据成员。类的静态成员函数没有this指针。这是因为静态成员函数为类的所有对象所共有，不属于某一个对象。
一般情况下，this指针隐式使用就可以了。但某些情况下需要显式使用。下面是需要显式使用this指针的两种情况：（1）在类的非静态成员函数中返回类对象本身的时候，直接使用“return *this;”。（2）另外一种情况是当参数与成员变量名相同时。
17、使用string类，必须在程序中包含头文件（  B  ）。
A、string.h B、string C、cstring.h D、cstring
★考核知识点: string类
附1.1.17（考核知识点解释）
使用string类，必须在程序中包含头文件string（注意，这里不是string.h，string.h是C字符串头文件）。
18、派生类中的成员不能访问基类中的（  A  ）。
A、私有成员 B、公有成员 C、保护成员 D、以上都可以
★考核知识点: 派生类的继承方式
附1.1.18（考核知识点解释）
以公有方式继承时，基类的公有成员和保护成员的访问控制方式在派生类中保持不变，仍作为派生类的公有成员和保护成员，基类的私有成员在派生类中不能直接访问。
以私有方式继承时，基类的公有成员和保护成员在派生类中都作为私有成员，基类的私有成员在派生类中不能直接访问。
以保护方式继承时，基类的公有成员和保护成员在派生类中都作为保护成员，基类的私有成员在派生类中无法直接访问。
19、基类的（  B  ）在私有继承时在派生类中为私有成员函数，在公有和保护继承时在派生类中为保护成员函数。
A、私有成员函数 B、保护成员函数
C、公有成员 D、保护数据成员
★考核知识点: 派生类的继承方式
附1.1.19（考核知识点解释）
以公有方式继承时，基类的公有成员和保护成员的访问控制方式在派生类中保持不变，仍作为派生类的公有成员和保护成员，基类的私有成员在派生类中不能直接访问。
以私有方式继承时，基类的公有成员和保护成员在派生类中都作为私有成员，基类的私有成员在派生类中不能直接访问。
以保护方式继承时，基类的公有成员和保护成员在派生类中都作为保护成员，基类的私有成员在派生类中无法直接访问。
20、类型兼容是指在基类对象可以出现的地方，都可以使用公有派生类的对象，已知：
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;
★考核知识点:类型兼容
附1.1.20（考核知识点解释）
类型兼容是指在基类对象可以出现的任何地方，都可以用公有派生类的对象来替代。类型兼容所指的是如下三种情况：
（1）派生类对象可以赋值给基类对象；
（2）派生类对象可以初始化基类的引用；
（3）基类指针可以指向派生类对象。
21、对于虚析构函数与一般虚函数，以下说法正确的是（  C  ）。
A、重定义函数就是派生类的构造函数
B、重定义函数就是派生类的析构函数，要求同名
C、一个虚析构函数的版本被调用执行后，接着就要执行其基类版本
D、基类和派生类都分别给出了一个虚函数的不同版本
★考核知识点:虚析构函数
附1.1.21（考核知识点解释）
在调用派生类对象的析构函数后，会自动调用基类对象的析构函数来释放基类中定义的指针成员。
22、下列关于虚函数的说明中，正确的是（  B  ）。
A、从虚基类继承的函数都是虚函数
B、虚函数不得是静态成员函数
C、只能通过指针或引用调用虚函数
D、抽象类中的成员函数都是虚函数
★考核知识点: 错误地使用虚函数
附1.1.22（考核知识点解释）
只有类的成员函数才能声明为虚函数。因为虚函数只适用于有继承关系的类对象，所以普通函数不能声明为虚函数。
静态成员函数不能是虚函数，因为静态成员函数不受限于某个对象。
内联函数不能是虚函数，因为内联函数不能在运行中确定其位置。即使虚函数放在类的内部定义，编译时，仍将其看作是非内联的。
构造函数不能是虚函数。因为构造时，对象还是一片未定型的空间。只有在构造完成后，对象才能成为一个类的名副其实的实例。
23、友元重载运算符obj1>obj2被C++编译器解释为（  A  ）。
A、operator>(obj1,obj2) B、>(obj1,obj2)
C、obj1.operator>(obj2) D、obj2.operator>(obj1)
★考核知识点:重载为类的友元函数
附1.1.23（考核知识点解释）
友元函数“Complex operator-(Complex &c1,Complex &c2);”实现了减法运算符的重载。该函数函数名为operator-，有两个对象引用作为形参，返回值类型为对象类型。在主函数中可以用c1-c2的形式调用operator-()函数，相当于：operator-(c1, c2);
24、在表达式x+y*z中，+ 是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（  C  ）。
A、operator+有两个参数，operator*有两个参数
B、operator+有两个参数，operator*有一个参数
C、operator+有一个参数，operator*有两个参数
D、operator+有一个参数，operator*有一个参数
★考核知识点:成员运算符函数与友元运算符函数的比较
附1.1.24（考核知识点解释）
双目运算符计算时需要两个操作数，所以调用运算符重载函数时必须将要计算的两个操作数传递给函数。对于成员重载函数，必须是某个对象调用这个函数，而且将这个对象的地址传递给this指针，因此调用函数的这个对象就可以作为一个操作数传递给函数，另一个操作数作为实参传递给形参即可，这样成员重载函数只需要一个参数即可。相对的，友元函数是系统直接调用，所以两个操作数都要作为实参传递到函数中去，所以友元重载函数需要两个参数。
25、下列运算符中，（  A  ）在C++中不能重载。
A、?: B、+ C、- D、<=
★考核知识点:运算符重载的规则
附1.1.25（考核知识点解释）
C++中不能重载的运算符只有5个：
. （成员访问运算符）
.*  （成员指针访问运算符）
:: （域运算符）
?: （条件运算符）
sizeof （长度运算符）
26、下列运算符中，必须使用成员函数进行重载的是（  B  ）。
A、== B、= C、>> D、++
★考核知识点:运算符重载的规则
附1.1.26（考核知识点解释）
C++规定，赋值运算符“=”，下标运算符“[]”，函数调用运算符“()”，类型转换运算符“()”，成员运算符“->”必须重载为成员函数。而插入运算符“<<”，提取运算符“>>”只能重载为非成员函数（友元函数）。
27、cout是I/O流库预定义的（  B  ）。
A、类 B、对象 C、常量 D、包含文件
★考核知识点:标准输入/输出流
附1.1.27（考核知识点解释）
从键盘输入、向屏幕输出称为标准输入/输出。为了实现标准输入/输出，C++预定义了4个标准流对象：cin、cout、cerr、clog，它们均包含于头文件iostream中。
28、4个预定义流对象为带缓冲的标准出错信息输出的是（  D  ）。
A、cin B、cout C、cerr D、clog
★考核知识点:标准输入/输出流
附1.1.28（考核知识点解释）
cin是istream类的对象，用于处理标准输入（键盘输入）；cout是ostream类的对象，用于处理标准输出（屏幕输出）；cerr和clog都是ostream类的对象，均用于处理出错信息标准输出。除了cerr不支持缓冲外，其他3个对象都支持缓冲输入/输出。
29、下面4个选项中，表示输入单个字符的是（  B  ）。
A、cin B、cin.get() C、cin.put() D、cin.getline()
★考核知识点:输入流的成员函数
附1.1.29（考核知识点解释）
istream类提供了用于输入单个字符的成员函数get()，istream的对象cin可以调用这个函数实现从键盘输入一个字符的操作。
cin调用get()有两种格式：
cin.get()
或
cin.get(ch)
其中，ch为字符型变量。
30、在C++中，打开一个文件，就是将该文件与（  B  ）建立关联；关闭一个文件，就是取消这种关联。
A、类 B、流对象 C、对象 D、结构
★考核知识点:文件的打开与关闭
附1.1.30（考核知识点解释）
对文件进行输入/输出即读/写操作，必须先打开文件，使得文件与流对象建立关联，然后利用流对象调用文件流类的运算符或成员函数实现对文件的读写操作，操作完毕后关闭文件。
31、以下选项中，错误的是（  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");
★考核知识点:文件的打开与关闭
附1.1.31（考核知识点解释）
打开文件使用文件流类的成员函数open()，当然在打开文件之前要先定义流对象，如：
ifstream infile;
infile.open("file1.txt");
或
ofstream outfile;
outfile.open("file2.txt");
首先定义文件流对象infile用于文件的输入（读）操作，然后文件流对象infile调用文件流类的成员函数open()，参数是要操作的磁盘文件名，open()函数实现的功能是打开文件file1.txt，并将流对象infile和文件建立关联。
也可将两条语句合并成一条语句，如：
ofstream outfile("file2.txt");
这样就是在定义时调用带参数的构造函数创建流对象outfile，参数为文件名file2.txt，这就是在构造函数中实现打开文件并将流对象outfile和文件建立关联的操作。
32、（  C  ）使一个函数可以定义成对不同数据类型完成相同操作。
A、重载函数 B、模板函数 C、函数模板 D、递归函数
★考核知识点:函数模板的概念
附1.1.32（考核知识点解释）
函数模板可以对不同类型的数据进行相同的处理，其作用与函数重载类似，但代码要简单得多。
33、函数模板的执行代码是在（  D  ）时生成的。
A、执行函数 B、源程序中声明函数
C、源程序中定义函数 D、源程序中调用函数
★考核知识点:函数模板的使用
附1.1.33（考核知识点解释）
函数模板需要实例化为模板函数后才能执行，即用实际的数据类型代替类型参数。实例化的函数模板称为模板函数。
函数模板的实例化是在函数调用时由编译器来完成的。当编译器遇到一个函数调用时，便根据实参表中实参的类型和已定义的函数模板生成一个模板函数，该模板函数的函数体与函数模板的函数体相同，而形参表中的类型则以实参表中的实际类型为依据。

（二）、判断部分
1、在C++程序中，主函数的函数名必须是main。（√）
★考核知识点:第一个C++程序
附1.2.1（考核知识点解释）
一个C++程序一般由多个函数组成。这些函数可以是用户根据需要编写的自定义函数，也可以是直接使用系统提供的标准库函数。函数体用一对花括号“{”和“}”括起来。任何一个程序必须有且仅有一个主函数main，程序从主函数开始执行。
2、类中所提供的成员函数可以直接访问该类的私有成员。（√）
★考核知识点:类成员的访问
附1.2.2（考核知识点解释）
在类体内，类的成员函数可以直接访问类中的任何成员。
3、类定义中的成员默认的访问权限是private。（√）
★考核知识点:类成员的访问控制
附1.2.3（考核知识点解释）
如果没有给出访问说明符，类默认的访问控制类型是private。
4、一个类中的保护成员和公有成员类似，在程序的任何地方都可以被访问。（×）
★考核知识点:类成员的访问控制
附1.2.4（考核知识点解释）
在public（公有）区域内声明的成员是公有成员。公有成员在程序的任何地方都可以被访问。一般将公有成员限制在成员函数上，使其作为类与外界的接口，程序通过这种函数来操作该类的对象。
在protected（保护）区域内声明的成员是被保护的成员。被声明为protected（保护）访问级别的数据成员或函数成员只能在该类的内部或其派生类类体中使用。
5、在一个类的成员函数中可以直接访问该类的私有成员变量，但不能直接访问该类的私有成员函数。（×）
★考核知识点:类成员的访问控制
附1.2.5（考核知识点解释）
在private（私有）区域内声明的成员是私有成员。私有成员只能被该类的成员函数或该类的友元访问。
6、一个类只能有一个构造函数。（×）
★考核知识点:构造函数
附1.2.6（考核知识点解释）
如果在类中声明了多个构造函数，这就是构造函数的重载。要求这些构造函数要有不同的参数表，系统自动调用构造函数时按照函数重载的规则选择其中的一个构造函数。
7、系统提供的缺省构造函数没有参数，所以自定义构造函数必须带有参数。（×）
★考核知识点:构造函数
附1.2.7（考核知识点解释）
若在类中定义一个带参构造函数，则系统不再提供默认的无参构造函数；若创建对象时需要调用无参构造函数，就必须在类中定义一个无参构造函数。
8、一旦自定义了构造函数，系统便不再提供缺省的构造函数。（√）
★考核知识点:构造函数
附1.2.8（考核知识点解释）
若在类中定义一个带参构造函数，则系统不再提供默认的无参构造函数；若创建对象时需要调用无参构造函数，就必须在类中定义一个无参构造函数。
9、一个类只能有一个析构函数。（√）
★考核知识点:析构函数
附1.2.9（考核知识点解释）
析构函数无参数，所以不能被重载。
10、在一个类中声明了某个静态数据成员，并在类外给出其定义和初始化后，若未定义该类的对象，该静态数据成员则不存在。（×）
★考核知识点:静态成员
附1.2.10（考核知识点解释）
在类的成员前如果加上关键字static，这种成员就是类的静态成员。类的静态成员包括静态数据成员和静态成员函数。类的静态成员的特点是：静态成员属于类，不属于任何对象。无论有多少对象或没有对象，静态成员都只有一份存于公用内存中，被该类的所有对象共享。
11、静态数据成员必须在类中进行定义和初始化。（×）
★考核知识点:静态数据成员
附1.2.11（考核知识点解释）
在类中声明的静态数据成员属于引用性说明，并不实际分配内存。在创建对象时，会为对象的数据成员分配存储空间。但由于静态数据成员不属于任何对象，所以在创建对象时也不会为该类的静态数据成员分配存储空间。所以，类设计者需要在类外对静态数据成员进行定义。静态数据成员的定义形式如下：
<类型><类名>::<静态数据成员名>[=<初值>];
12、静态成员函数中不能访问非静态成员。  （√）
★考核知识点:静态成员函数
附1.2.12（考核知识点解释）
如果成员函数被声明为static的，它就是静态成员函数。像静态成员数据一样，静态成员函数与具体对象无关。静态成员函数不能访问一般的数据成员，它只能访问静态数据成员，也只能调用其他的静态成员函数。
13、类A的友元函数的函数体内能够访问类A中的任何成员。（√）
★考核知识点:友元函数
附1.2.13（考核知识点解释）
将普通函数声明为类A的友元函数。声明后，普通函数有权访问类A中的任何成员，包括私有成员和保护成员。
14、如果类A是类B的友类，那么类A中的所有成员函数都可以访问类B中的所有成员。（√）
★考核知识点:友元
附1.2.14（考核知识点解释）
将类A声明为类B的友类。声明后，类A的任何成员函数都有权访问类B中的任何成员，包括私有成员和保护成员。
15、派生类至少有一个基类。  （√）
★考核知识点:什么是继承
附1.2.15（考核知识点解释）
在C++中，如果一个类C1通过继承已有类C而创建，则将C1称作派生类（也称做子类），将C称做基类（也称做父类）。派生类会继承基类中定义的所有属性和方法，另外也能够在派生类中定义派生类所特有的属性和方法。
16、在C++中，允许从一个类派生出任意多个类。（√）
★考核知识点:什么是继承
附1.2.16（考核知识点解释）
如：以形状类为基类，可以派生出各种特定的几何形状，如圆形、四边形、三角形……，它们在具有形状类所定义的属性和行为的同时，还拥有各自的特性。
17、释放派生类的对象时，首先调用基类的析构函数，然后调用派生类的析构函数。（×）
★考核知识点:派生类的构造函数和析构函数
附1.2.17（考核知识点解释）
派生类构造函数的作用主要是对派生类中新添加的数据成员做初始化工作；在创建派生类对象、执行派生类构造函数时，系统会自动调用基类的构造函数来对基类中定义的数据成员做初始化。同样，派生类析构函数的作用主要是清除派生类中新添加的数据成员、释放它们所占据的系统资源；在销毁派生类对象、执行派生类析构函数时，系统会自动调用基类的析构函数来释放基类中数据成员所占据的系统资源。
当创建派生类对象时，先调用基类的构造函数，再调用派生类的构造函数；析构函数调用顺序总是与构造函数调用顺序相反。
18、在C++中，不允许某个类同时从多个类派生。（×）
★考核知识点:多重继承
附1.2.18（考核知识点解释）
如果派生类是基于多个基类创建出来的，则称这个继承关系为多重继承。
19、已知：class Base1{//…};
      class Base2{//…};
      class Derived:public Base1, public Base2
      { Derived():Base2(),Base1(){}
            //…
      };
创建Derived类的对象时，先调用Base2的构造函数，然后调用Base1的构造函数，最后调用Derived的构造函数。（×）
★考核知识点: 派生类的构造函数和析构函数、多重继承
附1.2.19（考核知识点解释）
当创建派生类对象时，先调用基类的构造函数，再调用派生类的构造函数。
在多重继承中，各基类的构造顺序与派生类定义时基类表中各基类出现的顺序一致。而析构函数的调用顺序总是与构造函数调用顺序相反。
20、虚函数只有在有继承的情况时才会存在。（√）
★考核知识点:虚函数
附1.2.20（考核知识点解释）
面向对象程序设计语言采用“后期绑定”，也可叫“动态绑定”技术，即当调用某个对象的函数时，应该被执行的程序代码会根据对象的具体类型在执行期被确定下来。这是实现多态性的技术保证。
想要实现多态，就要进行“后期绑定”，在C++中，实现“后期绑定”的机制是虚函数。
只有将派生类对象赋给基类对象引用或将派生类对象地址赋给基类对象指针时，才能够表现出多态性。
21、基类的指针或引用调用虚函数时采用后期绑定。（√）
★考核知识点:虚函数
附1.2.21（考核知识点解释）
面向对象程序设计语言采用“后期绑定”，也可叫“动态绑定”技术，即当调用某个对象的函数时，应该被执行的程序代码会根据对象的具体类型在执行期被确定下来。这是实现多态性的技术保证。
想要实现多态，就要进行“后期绑定”，在C++中，实现“后期绑定”的机制是虚函数。
只有将派生类对象赋给基类对象引用或将派生类对象地址赋给基类对象指针时，才能够表现出多态性。
22、对虚函数的调用，系统都是采用动态联编。（×）
★考核知识点:虚函数的工作方式
附1.2.22（考核知识点解释）
只有将派生类对象赋给基类对象引用或将派生类对象地址赋给基类对象指针时，才能够表现出多态性。如果将派生类对象赋给基类对象，那么通过基类对象必然是调用基类中的函数。
23、抽象类虽然也是一种数据类型，但它不能建立对象，只能作为基类被其他类继承。（√）
★考核知识点:抽象类
附1.2.23（考核知识点解释）
通常将不需要实例化的类定义成“抽象类”。抽象类不能实例化为对象，它的唯一用途是为其他类提供合适的基类，其他类可从它这里继承和（或）实现接口。
24、拥有纯虚函数的类称为抽象类，它不能用来定义对象。（√）
★考核知识点:抽象类
附1.2.24（考核知识点解释）
一个类如果是抽象类，则该类中至少有一个成员函数是纯虚函数，纯虚函数就是在声明时初始化为0的虚函数。
抽象类不能实例化为对象，它的唯一用途是为其他类提供合适的基类，其他类可从它这里继承和（或）实现接口。
25、由抽象基类继承得到的派生类肯定是具体类。（×）
★考核知识点:抽象类
附1.2.25（考核知识点解释）
如果某个类是从一个带有纯虚函数的类派生出来的，并且没有在该派生类中提供该纯虚函数的定义，则该虚函数在派生类中仍然是纯虚函数，因而该派生类也是一个抽象类。
26、对二元运算符采用成员函数重载时，只需要一个参数，而且该参数可以是内部类型。（√）
★考核知识点:成员运算符函数与友元运算符函数的比较
附1.2.26（考核知识点解释）
双目运算符计算时需要两个操作数，所以调用运算符重载函数时必须将要计算的两个操作数传递给函数。对于成员重载函数，必须是某个对象调用这个函数，而且将这个对象的地址传递给this指针，因此调用函数的这个对象就可以作为一个操作数传递给函数，另一个操作数作为实参传递给形参即可，这样成员重载函数只需要一个参数即可。
27、对一元运算符采用某个类的友元函数重载时需要一个参数，参数为该类的对象，不能是其他类型。（√）
★考核知识点:成员运算符函数与友元运算符函数的比较
附1.2.27（考核知识点解释）
使用成员函数重载单目运算符，不需要参数。因为只有一个操作数，而成员函数需要对象调用，该对象即为操作数传递给函数。使用友元函数重载单目运算符，需要一个参数，操作数作为实参传递给函数。
无论是成员重载还是友元重载，单目运算符重载时操作数类型必须是该类的对象。成员函数是对象调用，这个对象就是操作数。而对于友元函数，参数是操作数，但是参数也要求必须是该类型的对象，如果是其他类的对象或内部类型将没有意义，系统也不允许。
28、重载插入运算符“<<”必须采用成员重载。（×）
★考核知识点:运算符重载的规则
附1.2.28（考核知识点解释）
C++规定，赋值运算符“=”，下标运算符“[]”，函数调用运算符“()”，类型转换运算符“()”，成员运算符“->”必须重载为成员函数。而插入运算符“<<”，提取运算符“>>”只能重载为非成员函数（友元函数）。
29、C++的输入/输出流库中，ios类是一个虚基类，istream类、ostream类以及streambuf类都是ios类的派生类。（×）
★考核知识点:输入/输出流类
附1.2.29（考核知识点解释）
ios是一个抽象基类，提供一些对流状态、工作方式等设置的功能。ios类作为虚基类派生出istream类和ostream类。输入流类istream提供输入操作功能，输出流类ostream提供输出操作功能。输入/输出流类iostream是从istream类和ostream类通过多重继承而派生的类。iostream类将输入、输出功能融合在一起，因此编写程序时一般包含头文件iostream以实现输入/输出操作，因为在该头文件中含有对输入/输出流类的定义及输入/输出操作的相关信息。streambuf类和其他类没有继承关系，该类提供缓冲输入/输出的支持。
30、设inf是一个ifstream类的流对象，则inf.seekg(10,ios::beg);表示将文件指针从文件当前位置向后移动10个字节。（×）
★考核知识点:文件的随机读/写
附1.2.30（考核知识点解释）
seekg()函数和seekp()函数分别用于定位输入文件和输出文件的文件指针。它们的原型为：
   isream& seekg(long offset,seek_dir origin=ios::beg);
   osream& seekp(long offset,seek_dir origin=ios::beg);
seekg()函数的功能是将输入文件的文件指针从参照位置origin开始移动offset个字节，定位到新的位置。seekp()函数的功能是将输出文件的文件指针从参照位置origin开始移动offset个字节，定位到新的位置。
其中，参数offset是长整型，表示文件指针相对参照位置偏移的字节数。参数origin则为参照位置，seek_dir是系统定义的枚举类型，有以下3个枚举常量：
ios::beg文件首
ios::cur文件当前位置
ios::end文件尾
origin可以有以上3个取值，默认参数值为ios::beg。

二、主观部分：

（一）、程序题
1、写出下面程序的运行结果。
#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[i]<<" ";
cout<<endl;
}
int main()
{
int a[size];
for(int i=0;i<size;i++)
get(a[i],i);
print(a);
for(int i=0;i<size;i++)
get(a[size-i-1],i);
print(a);
return 0;
}
参考资料：
0 1 2 3 4
4 3 2 1 0

2、写出下面程序的运行结果。
#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;
}
参考资料：
1 2 3 4 5
1 9 3 4 5

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;
}
参考资料：
x=0,y=0
x=2,y=3

4、写出下面程序的运行结果。
#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;
}
参考资料：
A=2,B=7
A=5,B=7

5、写出下面程序的运行结果。
#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;
}
参考资料：
class Base
class Base
class Base
class Derived1
class Derived2

6、写出下面程序的运行结果。
#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;
}
参考资料：
Shape
area:314
Shape
area:15

7、写出下面程序的运行结果。
#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;
}
参考资料：
n=10
n=30

8、写出下面程序的运行结果。
#include <iostream>
using namespace std;
class Sample
{
public:
Sample(int i){n=i;}
void operator++(){n++;}
void 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;
}
参考资料：
n=4
n=3

9、写出下面程序的运行结果。
#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;
}
参考资料：
i+j=186

10、写出下面程序的运行结果。
#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;
}
参考资料：
s1=185
s2=36.5

11、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;
}

12、下面的程序定义了两个类，一个是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;
}

13、请将下面程序补充完整。
#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;
}

14、请补充完整下面类说明中的拷贝构造函数。
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[i] = mc.p[i];
}
};

15、将下列程序填写完整。
#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;
}

16、将下列程序填写完整。
#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);
ss.Sleep();
ss.WatchTV();
return 0;
}

17、下面的程序将一个普通函数作为类的友元函数，求坐标点之和，并且程序输出结果为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;
}

18、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 i);
};
ARRAY::ARRAY(int a[], int n)
{
if( n<=0 )
{  v=NULL; s=0; return;  }
s=n;
v=new int[s];
for(int i=0; i<n; i++)
v[i]=a[i];
}
int& ARRAY:

perator[](int i)
{
return v[i];
}

19、下面程序的功能是将文本文件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;
}

20、下面程序的功能是：在文件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[i]);
outstr.close();
return 0;
}

21、下面程序的功能是：统计文件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;
}

22、下面的程序将一个已有文件的内容复制到另一个文件中。请将程序补充完整。
#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;
}

23、下面的程序是一个类模板，可实现求三个变量的和，请将程序补充完整。
#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;
}

24、编写一个计算长方形面积的程序。设长和宽为整数，其值由键盘输入，计算结果显示在屏幕上。
参考资料：
#include <iostream>
using namespace std;
int ComputeRectangleArea(int nL, int nW)
{
int nA = nL * nW;
return nA;
}
int main()
{
int nWidth, nLength, nArea;
cout<<"请输入长方形的长度和宽度（长宽都为整数）：";
cin>>nLength>>nWidth;
nArea = ComputeRectangleArea(nLength, nWidth);
cout<<"长方形的面积为："<<nArea<<endl;
return 0;
}

25、编写简单计算器程序，使它能够进行四则运算。例如：
输入：3+9
输出：3+9=12
参考资料：
#include <iostream>
using namespace std;
int main()
{
double dA, dB, dR;
char cC;
cout<<"请输入四则运算式：";
cin>>dA>>cC>>dB; // 3.5+9.3
switch (cC)
{
case '+':
dR = dA + dB;
break;
case '-':
dR = dA - dB;
break;
case '*':
dR = dA * dB;
break;
case '/':
dR = dA / dB;
break;
default:
cout<<"输入四则运算式的格式不正确！"<<endl;
return 0;
}
cout<<"运算结果为："<<dA<<cC<<dB<<"="<<dR<<endl;
return 0;
}

26、编写程序，将一个十进制正整数按倒序形式输出。例如：输入123，则输出321。
参考资料：
#include <iostream>
using namespace std;
int main()
{
int nInput, nS, nY, nR = 0;
cout<<"请输入一个十进制的正整数：";
cin>>nInput;
nS = nInput;
while (nS != 0)
{
nY = nS % 10;
nR = nR*10+nY;
nS = nS / 10;
}
cout<<"其倒序形式为："<<nR<<endl;
return 0;
}

27、编写程序，求20以内的勾股数。例如：32+42=52，3、4、5是勾股数。
参考资料：
#include <iostream>
using namespace std;
int main()
{
int nA, nB, nC; // nA^2+nB^2=nC^2
for (nC = 1; nC <= 20; nC++)
{
for (nB = 1; nB < nC; nB++)
{
for (nA = 1; nA <= nB; nA++)
{
if (nA*nA+nB*nB == nC*nC)
{
cout<<nA<<" "<<nB<<" "<<nC<<endl;
}
}
}
}
return 0;
}

28、编写display函数，其功能为：当传入一个字符串参数时，则将该字符串输出到屏幕上；当不传入任何参数时，则输出“noname”。例如：
执行“display("Li Xiaoming");”后，在屏幕上输出“Li Xiaoming”。
执行“display()”后，在屏幕上输出“noname”。
参考资料：
以默认形参方式实现：
#include <iostream>
using namespace std;
void Display(char *s = "noname")
{
cout<<s<<endl;
}
int main()
{
Display("Li Xiaoming");
Display();
return 0;
}

以函数重载方式实现：
#include <iostream>
using namespace std;
void Display(char *s);
void Display();
int main()
{
Display("Li Xiaoming");
Display();
return 0;
}
void Display(char *s)
{
cout<<s<<endl;
}
void Display()
{
cout<<"noname"<<endl;
}

29、编写程序，定义两个重载函数，分别求平面中两个整数（int）坐标点间的距离和两个实数（float）坐标点间的距离，其计算结果都为实数。
参考资料：
#include <iostream>
#include <cmath>
using namespace std;
double ComputeDistance(int nX1, int nY1, int nX2, int nY2)
{
double dR;
dR = sqrt((double)(nX1-nX2)*(nX1-nX2)+(nY1-nY2)*(nY1-nY2));
cout<<"double ComputeDistance(int nX1, int nY1, int nX2, int nY2)函数被调用！"<<endl;
return dR;
}
double ComputeDistance(float fX1, float fY1, float fX2, float fY2)
{
double dR;
dR = sqrt((fX1-fX2)*(fX1-fX2)+(fY1-fY2)*(fY1-fY2));
cout<<"double ComputeDistance(float fX1, float fY1, float fX2, float fY2)函数被调用！"<<endl;
return dR;
}
int main()
{
cout<<ComputeDistance(1, 2, 3, 4)<<endl;
cout<<ComputeDistance(1.5f, 2.5f, 3.5f, 4.6f)<<endl;
return 0;
}

30、编写程序，定义两个重载函数GetMax，分别求两个整数的最大值和一个整型数组中各元素的最大值。例如：
cout<<getMax(3, 4); //输出4
int a[] = {5, 15, 10, -6, 7};
// 输出数组a中的最大值15
cout<<getMax(a, sizeof(a)/sizeof(int));
参考资料：
#include <iostream>
using namespace std;
int GetMax(int nA, int nB);
int GetMax(int nArray[], int nSize);
int main()
{
int nA[] = {5, 10, -6, 7, 25, 15};
cout<<GetMax(3, 4)<<endl;
cout<<GetMax(nA, sizeof(nA)/sizeof(nA[0]))<<endl;
return 0;
}
int GetMax(int nA, int nB)
{
cout<<"int GetMax(int nA, int nB)函数被调用！"<<endl;
return nA > nB ? nA : nB;
}
int GetMax(int nArray[], int nSize)
{
int nMax = nArray[0], nI;
for (nI = 1; nI < nSize; nI++)
{
if (nMax < nArray[nI])
nMax = nArray[nI];
}
cout<<"int GetMax(int nArray[], int nSize)函数被调用！"<<endl;
return nMax;
}

31、编写程序，从键盘输入学生的数量，根据学生数量为其动态分配内存空间，并从键盘输入每一名学生的学号、姓名和3科成绩。计算并输出每一名学生的学号、姓名和总成绩。（提示：定义一个学生结构体）
参考资料：
#include <iostream>
using namespace std;
struct STU
{
char sNo[9]; // 用于存储学生学号（假设学生学号为位）
char sName[10]; // 用于存储学生姓名
int nScore[3]; // 用于存储学生三门课程的成绩
};
int main()
{
STU *pStu = NULL; // 表示指向一片无效内存
int nStuNum, nI, nJ, nTotal;
cout<<"请输入学生数量：";
cin>>nStuNum;
if (nStuNum <= 0)
{
cout<<"学生数量必须大于！"<<endl;
return 0;
}
pStu = new STU[nStuNum];
if (pStu == NULL)
{
cout<<"内存分配失败！"<<endl;
return 0;
}
for (nI = 0; nI < nStuNum; nI++)
{
cout<<"请输入第"<<nI+1<<"名学生的学号、姓名和三科成绩：";
cin>>pStu[nI].sNo>>pStu[nI].sName;
for (nJ = 0; nJ < 3; nJ++)
{
cin>>pStu[nI].nScore[nJ];
}
}
for (nI = 0; nI < nStuNum; nI++)
{
nTotal = 0;
for (nJ = 0; nJ < 3; nJ++)
{
nTotal += pStu[nI].nScore[nJ];
}
cout<<"第"<<nI+1<<"名学生的学号、姓名和总成绩为：";
cout<<pStu[nI].sNo<<" "<<pStu[nI].sName<<" "<<nTotal<<endl;
}
delete []pStu;
pStu = NULL; // 当值针指向无效内存时，及时将它赋值为NULL
return 0;
}
32、编写swap函数，利用引用实现两个变量的值的交换。例如：
int a, b;
cin>>a>>b; // 输入3和4
swap(a, b); // 交换a和b的值
// 输出4和3
cout<<a<<" "<<b<<endl;
参考资料：
#include <iostream>
using namespace std;
void swap(int &nX, int &nY);
int main()
{
int nA, nB;
cout<<"请输入两个整数：";
cin>>nA>>nB; // 输入和
swap(nA, nB);
cout<<"交换后的值为："<<nA<<" "<<nB<<endl;
return 0;
}
void swap(int &nX, int &nY)
{
int nTemp;
nTemp = nX;
nX = nY;
nY = nTemp;
}

33、已知全局数组：
int array[5] = {1, 2, 3, 4, 5};
要求编写函数index，通过赋值语句“index(i)=x;”，可以将array[i]的值改为x。例如：
index(1) = 10;
cout<<array[1]; // 输出10
参考资料：
#include <iostream>
using namespace std;
int nArray[] = {1, 2, 3, 4, 5};
int& Index(int nI);
int main()
{
cout<<"更改前的nArray[1]的值为："<<nArray[1]<<endl;
Index(1) = 10;
cout<<"更改后的nArray[1]的值为："<<nArray[1]<<endl;
return 0;
}
int& Index(int nI)
{
return nArray[nI];
}
34、编写程序，自定义类Complex。要求：
（1）通过使用类成员函数来实现复数的加法运算。
（2）对成员函数的调用样式如：obj1.AddCom(obj2)
参考资料：
#include <iostream>
using namespace std;
class Complex
{
public:
Complex(double dR, double dI);
void AddCom(Complex &c);
void Display();
private:
double m_dR;
double m_dI;
};
Complex::Complex(double dR, double dI)
{
m_dR = dR;
m_dI = dI;
}
void Complex::AddCom(Complex &c)
{
m_dR = m_dR+c.m_dR;
m_dI = m_dI+c.m_dI;
}
void Complex:

isplay()
{
if (m_dI >= 0)
cout<<m_dR<<"+"<<m_dI<<"i"<<endl;
else
cout<<m_dR<<"-"<<-m_dI<<"i"<<endl;
}
int main()
{
Complex c1(1, 2), c2(3, -5);
c1.AddCom(c2);
cout<<"加法运算的结果为：";
c1.Display();
return 0;
}

35、编写程序，自定义类String。要求：通过使用类成员函数s1.AddDgt(s2)来求出两个串中数字字符的个数和。
参考资料：
#include <string>
#include <iostream>
using namespace std;
class String
{
public:
String(string str);
int AddDgt(String &s);
private:
string m_str;
};
String::String(string str)
{
m_str = str;
}
int String::AddDgt(String &s)
{
int nCount = 0, nI;
for (nI = 0; nI < m_str.size(); nI++)
{
if (m_str[nI] >= '0' && m_str[nI] <= '9')
{
nCount++;
}
}
for (nI = 0; nI < s.m_str.size(); nI++)
{
if (s.m_str[nI] >= '0' && s.m_str[nI] <= '9')
{
nCount++;
}
}
return nCount;
}
int main()
{
String s1("1a2b3c4"), s2("d56ef78gh9");
cout<<s1.AddDgt(s2)<<endl;
return 0;
}

36、编写程序，定义Ship和AirPlane两个类，二者都有重量属性，定义二者的友元函数ComparWeight()和TotalWeight()，分别比较两者重量的大小和计算两者重量和。
参考资料：
#include <iostream>
using namespace std;
class AirPlane;
class Ship
{
public:
friend float CompareWeight(Ship &ship, AirPlane &airplane);
friend float TotalWeight(Ship &ship, AirPlane &airplane);
Ship(float fWeight);
private:
float m_fWeight;
};
Ship::Ship(float fWeight)
{
if (fWeight <= 0.0f)
{
cout<<"轮船重量必须大于0，因参数错误轮船重量将被初始化为1.0！"<<endl;
fWeight = 1.0f;
}
m_fWeight = fWeight;
}
class AirPlane
{
public:
friend float CompareWeight(Ship &ship, AirPlane &airplane);
friend float TotalWeight(Ship &ship, AirPlane &airplane);
AirPlane(float fWeight);
private:
float m_fWeight;
};
AirPlane::AirPlane(float fWeight)
{
if (fWeight <= 0.0f)
{
cout<<"飞机重量必须大于0，因传入参数无效飞机重量将被设为默认值1.0"<<endl;
fWeight = 1.0f;
}
m_fWeight = fWeight;
}
float CompareWeight(Ship &ship, AirPlane &airplane)
{
return ship.m_fWeight - airplane.m_fWeight;
}

float TotalWeight(Ship &ship, AirPlane &airplane)
{
return ship.m_fWeight + airplane.m_fWeight;
}
int main()
{
Ship ship(0.0f);
AirPlane airplane(2.0f);
float fCompare;
fCompare = CompareWeight(ship, airplane);
if (fCompare > 0.0f)
{
cout<<"轮船比飞机重！"<<endl;
}
else if (fCompare == 0.0f)
{
cout<<"轮船与飞机一样重！"<<endl;
}
else
{
cout<<"飞机比轮船重！"<<endl;
}
cout<<"轮船与飞机的重量和为："<<TotalWeight(ship, airplane)<<endl;
return 0;
}

37、编写程序，实现学生类Student，包括学生姓名、成绩，要求：
（1）设计一个友元函数Compare()，比较两个学生成绩的高低。
（2）在main()函数中定义一个对象数组用于存储输入学生的数据，并求出最高分和最低分的学生。
参考资料：
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
friend int Compare(Student &stu1, Student &stu2);
friend void DisplayScoreLevel(Student &stu);
bool SetData(string strName, int nScore); // 设置学生信息
void GetData(string &strName, int &nScore); // 获取学生信息
private:
string m_strName; // 保存学生姓名
int m_nScore; // 保存学生成绩
};
bool Student::SetData(string strName, int nScore)
{
if (nScore < 0 || nScore > 100)
{
cout<<"传入的成绩信息无效，成绩应在~100之间！"<<endl;
return false;
}
m_strName = strName;
m_nScore = nScore;
return true;
}
void Student::GetData(string &strName, int &nScore)
{
strName = m_strName;
nScore = m_nScore;
}
int Compare(Student &stu1, Student &stu2)
{
return stu1.m_nScore-stu2.m_nScore;
}
int main()
{
Student stu[3];
string strName, strName2;
int nScore, nScore2;
int nI, nStuNum = sizeof(stu)/sizeof(stu[0]), nMin, nMax;
for (nI = 0; nI < nStuNum; nI++)
{
cout<<"请输入第"<<nI+1<<"名学生的姓名和成绩：";
cin>>strName>>nScore;
if (!stu[nI].SetData(strName, nScore))
{
nI--;
}
}
nMin = nMax = 0;
for (nI = 1; nI < nStuNum; nI++)
{
stu[nMin].GetData(strName, nScore);
stu[nI].GetData(strName2, nScore2);
if (nScore > nScore2)
{
nMin = nI;
}
stu[nMax].GetData(strName, nScore);
if (nScore < nScore2)
{
nMax = nI;
}
}
stu[nMin].GetData(strName, nScore);
cout<<"成绩最低的学生信息："<<strName<<","<<nScore<<endl;
stu[nMax].GetData(strName, nScore);
cout<<"成绩最高的学生信息："<<strName<<","<<nScore<<endl;
return 0;
}

38、编写程序，实现一个计算器类Calculator，具有整数的加、减、乘、除的功能。再编写一个类ECalculator，继承Calculator类，增加求阶乘和绝对值的方法。编写主函数测试ECalculator类的功能。
参考资料：
#include <iostream>
using namespace std;
class Calculator
{
public:
int Add(int nOp1, int nOp2) { return nOp1+nOp2; }
int Sub(int nOp1, int nOp2) { return nOp1-nOp2; }
int Mul(int nOp1, int nOp2) { return nOp1*nOp2; }
bool Div(int nOp1, int nOp2, double &dR);
};
bool Calculator:

iv(int nOp1, int nOp2, double &dR)
{
if (nOp2 == 0)
return false;
dR = (double)nOp1/nOp2;
return true;
}
class ECalculator : public Calculator
{
public:
int Jc(int nOp);
int Abs(int nOp) { return nOp>0?nOp:-nOp; }
};
int ECalculator::Jc(int nOp)
{
int nJc = 1, nI;
for (nI = 2; nI <= nOp; nI++)
{
nJc *= nI;
}
return nJc;
}
int main()
{
ECalculator e;
double dR;
cout<<e.Add(3, 5)<<endl;
cout<<e.Sub(3, 5)<<endl;
cout<<e.Mul(3, 5)<<endl;
cout<<e.Abs(5)<<endl;
cout<<e.Abs(-5)<<endl;
if (e.Div(3, 5, dR) == true)
cout<<dR<<endl;
else
cout<<"除法运算失败！"<<endl;
cout<<e.Jc(5)<<endl;
return 0;
}

39、编写程序，实现一个三角形类Triangle，包含三角形三条边长的私有数据成员，另有一个重载运算符“+”，以实现求两个三角形对象的面积之和。要求用成员重载函数实现。
参考资料：
#include <iostream>
#include <cmath>
using namespace std;
class Triangle
{
public:
Triangle(double dA, double dB, double dC);
void Display();
double Area();
double operator+(Triangle &t);
private:
double m_dA, m_dB, m_dC;
};
Triangle::Triangle(double dA, double dB, double dC)
{
m_dA = dA;
m_dB = dB;
m_dC = dC;
}
void Triangle:

isplay()
{
cout<<"三角形的三条边长和面积分别为："<<m_dA<<" "<<m_dB<<" "<<m_dC<<" "<<Area()<<endl;
}
double Triangle::Area()
{
double dS = (m_dA+m_dB+m_dC)/2;
return sqrt(dS*(dS-m_dA)*(dS-m_dB)*(dS-m_dC));
}
double Triangle:

perator +(Triangle &t)
{
return Area()+t.Area();
}
int main()
{
Triangle t1(3,4,5), t2(4,5,6);
t1.Display();
t2.Display();
cout<<"面积和为："<<t1+t2<<endl;
return 0;
}

40、编写程序，实现一个学生类Student，包括姓名和三门课程成绩，利用重载运算符“<”比较两名学生的总成绩。然后定义一批学生，按总成绩升序排序，并输出结果。要求用友元重载函数实现。
参考资料：
#include <iostream>
#include <string>
using namespace std;
class Student;
bool operator<(Student &s1, Student &s2);
class Student
{
friend bool operator<(Student &s1, Student &s2);
public:
Student();
void SetData(string strName, int nScore[]);
void Display();
private:
string m_strName;
int m_nScore[3];
};
Student::Student()
{
m_strName = "noname";
m_nScore[0] = m_nScore[1] = m_nScore[2] = 0;
}
void Student::SetData(string strName, int nScore[])
{
int nI;
m_strName = strName;
for (nI = 0; nI < 3; nI++)
{
m_nScore[nI] = nScore[nI];
}
}
void Student:

isplay()
{
cout<<"学生的姓名、三门课程成绩和总成绩分别为："
<<m_strName<<" "<<m_nScore[0]<<" "<<m_nScore[1]<<" "<<m_nScore[2]<<" "
<<m_nScore[0]+m_nScore[1]+m_nScore[2]<<endl;
}
bool operator<(Student &s1, Student &s2)
{
int nTotal1=0, nTotal2=0;
nTotal1 = s1.m_nScore[0]+s1.m_nScore[1]+s1.m_nScore[2];
nTotal2 = s2.m_nScore[0]+s2.m_nScore[1]+s2.m_nScore[2];
if (nTotal1 < nTotal2)
return true;
else
return false;
}
int main()
{
Student stu[3], stuTemp;
string strName;
int nScore[3];
int nI, nJ, nK;
for (nI = 0; nI < 3; nI++)
{
cout<<"请输入第"<<nI+1<<"名学生的姓名和三门课程的成绩：";
cin>>strName>>nScore[0]>>nScore[1]>>nScore[2];
stu[nI].SetData(strName, nScore);
}
for (nI = 0; nI < 3; nI++)
{
nK = nI;
for (nJ = nI+1; nJ < 3; nJ++)
{
if (stu[nJ] < stu[nK])
{
nK = nJ;
}
}
if (nI != nK)
{
stuTemp = stu[nI];
stu[nI] = stu[nK];
stu[nK] = stuTemp;
}
}
for (nI = 0; nI < 3; nI++)
stu[nI].Display();
return 0;
}

41、编写程序，实现Time类，在Time类中设计重载运算符函数使得如下运算成立：
Time t(23, 59, 59);
(t++).Display(); // 输出23:59:59
t.Display(); // 输出0:0:0
(--t).Display(); // 输出23:59:59
t.Display(); // 输出23:59:59
参考资料：
#include <iostream>
using namespace std;
class Time
{
public:
Time(int nHour, int nMinute, int nSecond);
Time operator++(int);
Time& operator--();
void Display();
private:
int m_nHour, m_nMinute, m_nSecond;
};
Time::Time(int nHour, int nMinute, int nSecond)
{
m_nHour = nHour;
m_nMinute = nMinute;
m_nSecond = nSecond;
}
void Time:

isplay()
{
cout<<m_nHour<<":"<<m_nMinute<<":"<<m_nSecond<<endl;
}
Time Time:

perator ++(int)
{
Time t(*this);
m_nSecond++;
if (m_nSecond == 60)
{
m_nSecond = 0;
m_nMinute++;
if (m_nMinute == 60)
{
m_nMinute = 0;
m_nHour++;
if (m_nHour == 24)
{
m_nHour = 0;
}
}
}
return t;
}
Time& Time:

perator --()
{
m_nSecond--;
if (m_nSecond < 0)
{
m_nSecond = 59;
m_nMinute--;
if (m_nMinute < 0)
{
m_nMinute = 59;
m_nHour--;
if (m_nHour < 0)
{
m_nHour = 23;
}
}
}
return *this;
}
int main()
{
Time t(23, 59, 59);
(t++).Display(); // 输出23:59:59
t.Display(); // 输出0:0:0
(--t).Display(); // 输出23:59:59
t.Display(); // 输出23:59:59
return 0;
}

42、编写程序，将斐波那契数列(1, 1, 2, 3, 5, 8, 13……)的前20项以文本方式写入文件fb.dat中，然后从该文件中读出前10项，计算它们的和，并显示在屏幕上。
参考资料：
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ofstream out;
ifstream in;
int nI, nJ, nK, nTemp, nSum;
out.open("fb.dat");
if (!out)
{
cout<<"文件打开失败！"<<endl;
abort();
}
nI = 1;
nJ = 0;
for (nK = 0; nK < 20; nK++)
{
out<<nI<<" ";
nTemp = nJ;
nJ = nI;
nI = nJ+nTemp;
}
out.close();
in.open("fb.dat");
if (!in)
{
cout<<"文件打开失败！"<<endl;
abort();
}
nSum = 0;
for (nK = 0; nK < 10; nK++)
{
in>>nI;
nSum += nI;
}
in.close();
cout<<"前十项的和为："<<nSum<<endl;
return 0;
}

43、编写程序，自定义Point类，其对象表示平面上的一个点(x, y)，通过重载运算符“>>”和“<<”，来实现类对象的输入与输出。
参考资料：
#include <iostream>
using namespace std;
class Point;
istream& operator>>(istream&, Point&);
ostream& operator<<(ostream&, Point&);
class Point
{
friend istream& operator>>(istream&, Point&);
friend ostream& operator<<(ostream&, Point&);
private:
double m_dX, m_dY;
};
istream& operator>>(istream& in, Point& p)
{
in>>p.m_dX>>p.m_dY;
return in;
}
ostream& operator<<(ostream& out, Point& p)
{
out<<"("<<p.m_dX<<","<<p.m_dY<<")"<<endl;
return out;
}
int main()
{
Point p;
cout<<"请输入点的坐标：";
cin>>p;
cout<<p;
return 0;
}

44、编写程序，设计两个函数模板，其功能分别是返回两个值中的较大者和返回多个值中的较大者。要求不仅能够处理整型、实型等数值型数据，而且能够正确处理字符串。
参考资料：
#include <iostream>
using namespace std;
template <class T> T compmax(T x, T y)
{ return x>y?x:y; }
template <class T> T compmax(T arr[], int nSize)
{
T tmax = arr[0];
int nI;
for (nI = 1; nI < nSize; nI++)
if (tmax < arr[nI])
tmax = arr[nI];
return tmax;
}
char* compmax(char* cStr1, char* cStr2)
{
if (strcmp(cStr1, cStr2) > 0) return cStr1;
else return cStr2;
}
char* compmax(char* cStrArray[], int nSize)
{
int nI;
char* cMaxStr = cStrArray[0];
for (nI = 1; nI < nSize; nI++)
{
if (strcmp(cStrArray[nI], cMaxStr) > 0)
{ cMaxStr = cStrArray[nI]; }
}
return cMaxStr;
}
int main()
{
double dArr[] = {3.5, 7.2, 4.3, 6.8};
char* cStrArr[] = {"Beijing", "Shanghai", "Tianjin"};
cout<<compmax(3.5, 4.6)<<endl;
cout<<compmax("def", "abc")<<endl;
cout<<compmax(dArr, sizeof(dArr)/sizeof(dArr[0]))<<endl;
cout<<compmax(cStrArr, sizeof(cStrArr)/sizeof(cStrArr[0]))<<endl;
return 0;
}

45、编写程序，用类模板设计一个通用数组类（即可以在创建对象时指定数组中元素的类型和数目）。
参考资料：
#include <iostream>
using namespace std;
template <class T>
class Array
{
public:
Array(int nSize);
~Array();
T& operator[](int nIndex);
void Display();
private:
T *m_pArray;
int m_nSize;
};
template <class T>
Array<T>::Array(int nSize)
{
m_nSize = nSize;
m_pArray = new T[nSize];
}
template <class T>
Array<T>::~Array()
{
delete []m_pArray;
}
template <class T>
T& Array<T>:

perator [](int nIndex)
{
return m_pArray[nIndex];
}
template <class T>
void Array<T>:

isplay()
{
int nI;
for (nI = 0; nI < m_nSize; nI++)
{
cout<<m_pArray[nI]<<" ";
}
cout<<endl;
}
int main()
{
Array<int> nArray(10);
Array<double> dArray(10);
Array<char> cArray(10);
int nI;
for (nI = 0; nI < 10; nI++)
{
nArray[nI] = nI;
dArray[nI] = nI+9.8;
cArray[nI] = nI+'a';
}
nArray.Display();
dArray.Display();
cArray.Display();
return 0;
}

		自动登录	找回密码
密码			会员注册

VIP会员，3年作业免费下！	奥鹏作业，奥鹏毕业论文检测	新手作业下载教程，充值问题	没有找到答案，请在此处留言！
2022年5月最新全国统考资料	投诉建议，加盟合作！		奥鹏课程积分软件(2021年最新)

南开15春《面向对象程序设计》期末复习资料

相关帖子