东南大学C++试卷(模拟)

（考试用时90分钟）

一、选择题（每题1分，共5分）

1．对于面向对象的程序设计（OOP）和过程性（SP）的程序设计，那些说法是正确的             。

A．面向对象的程序设计和过程性程序设计是两个的程序设计范型。

B．面向对象的程序设计和过程性程序设计不是两个的程序设计范型，前者包含后者。将两者分开并列是不妥的。

C．面向对象是编程的总体框架，而过程性是编写解决具体问题的程序段的工具。

D．面向对象只是一种语法现象，而过程性程序设计才是编程的工具。

2．下面有关函数调用的说法哪一个是错误的             。

A．实参与形参的数目要求必须是相同的。

B．实参与形参的对应关系取决于位置而不是名字。

C．实参与对应的形参应类型匹配，即实参的类型可以转化为形参类型。

D．C++有两种调用方式：传值与引用。

3．C++中表示字符A的正确方法是            。

A．’\65’       B．”A”       C．65       D．’A’

4．有关函数重载的要求哪一个是正确的            。

A．必须保证参数类型和返回值类型均不同。

B．必须保证返回值类型不同。

C．必须保证参数的数量不同。 

D．必须保证参数类型或数量不同。

5．下列有关枚举类型的说明哪些是错误的？            

A．枚举常量（或称枚举成员）是以标识符形式表示的整型量。

B．默认状态下，这个整数就是所列举元素的序号，序号从0开始。

C．类型定义时可以为部分或全部枚举常量指定整数值，其余的枚举常量仍按默认方式取值。 

D．各枚举常量的值可以重复，但各枚举常量标识符必须不同。

二、简答题（每题1分，共5分）

1．什么是逻辑表达式的求值优化？举例说明。

2．下面4个类定义中，是否有错？如有错请说明错在哪里。

  (1) class Square{

     private:

         int upper_left_x, upper_left_y;

        int side_length;

     public:

        void Square(int x=0,int y=0,int len=2);

        ~Square();

int draw();

};

  (2) class Circle{

private:

    register int atom_x,atom_y;

    auto int radius;

public:

    Circle(int x=0,int y=0,int radius=3);

    ~ Circle();

    int darw();

};

(3) class Figure{

     public:

        Figure();

~ Figure(bool have_drawn);

};

  (4) class Line{

     private:

        int start_x=0,start_y=0;

        int end_x=0,end_y=0;

     public:

        int draw();

        int is_on_line(int x,int y);

};

三、阅读程序段（每题5分，共20分）

1．以下是运输公司对所运货物计费的程序。

设每公里每吨的基本运费为p，货物重量为w，总运输里程在某段中的里程为Δs，折扣为d，则该段运费为：p*w*Δs*(1-d)。总费用为各段费用之和，采用不加break的switch语句。

int main(){

    int c,s;

    double p,w,d,f;

cout<<"输入运输单价p，重量w和里程s:"< cin>>p>>w>>s;

    f=0;

    c=s/250;

    switch(c){

        default:d=0.15;f+=p*w*(s-3000)*(1-d);s=3000;

        case 8: case 9: case 10: case 11: d=0.1;f+=p*w*(s-2000)*(1-d);s=2000;

        case 4: case 5: case 6:  case 7: d=0.08;f+=p*w*(s-1000)*(1-d);s=1000;

        case 2: case 3: d=0.05;f+=p*w*(s-500)*(1-d);s=500;

        case 1: d=0.02;f+=p*w*(s-250)*(1-d);s=250;

        case 0: d=0;f+=p*w*s*(1-d);

    }

cout<<"运输单价:"< cout<<"折扣后运费:"<    return 0;

}

运输公司是怎样分段的？并给出各段的折扣率。，设输入运输单价、重量和里程为0.5  40  4300，输出结果是什么？

2．下面的程序演示静态局部变量的应用。请写出程序运行的输出结果。

  void tripe_it(int);

  void main(){

    int i;

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

      tripe_it(i);

    return;

  }

  void tripe_it(int i){

    static int total = 0;    // local and static

    int ans;                 // local and automatic

    ans=i*3;

    total+=ans;

cout<<"Sum of 1*3 to "<    return;

  }

3．写出以下程序中递归函数求解的数学式。

#include

using namespace std;

double P(int n,double x){

    if(n==0) return 1;

    if(n==1) return x;

    return ((2*n-1)*x*P(n-1,x)-(n-1)*P(n-2,x))/n;

}

int main(){

cout<<"P(4,1.5)="<    return 0;

}

4．给出输出的结果。

void swap(int &,int &);

int main(){

int i=3,j=5;

 swap(i,j);

 cout<<"i="< cin>>n;

 s=      (4)     ;

cout<<"The result is "< return 0;

} 

int f(int n){   //递归法求平方和函数

  if (    (5)    )   return 1;

  else   return (   (6)   );

}

3．若一头小母牛从出生第四个年头开始每年生一头母牛，按此规律，第n年时总共会有多少头母牛。采用递推算法。

void main(){

  int n,i;

  long a=0, b=0, c=0, d=1，temp;

//a是3岁及以上母牛数，b是2岁，c是1岁，d是0岁

cout <<"请输入年数n: ";

cin >>n;

cout<  for(i=1; i         (7)     ;     //第n年时，3岁及以上母牛数

     (8)     ;     //第n年时，2岁母牛数

          (9)     ;     //第n年时，1岁母牛数

          (10)    ;     //第n年时，新生牛数

  }

cout <<"第n年总共有"<<    (11)     <<"头母牛。"<}

4．将100元换成用10元、5元和1元的组合，共有多少种组合方法。采用穷举法。考虑10元最多10张，5元最多20张，余下是1元。

int main(){

    int i,j,k,count=0;

    for(i=0;   (12)   ;i++)//i是10元张数，j是5元张数，k是1元张数

        for(j=0;   (13)   ;j++){

            k=   (14)   ;

            if(   (15)   ){

             cout<                count++;

            }

        }

cout<    return 0;

}

答案：

一、选择题（每题1分，共5分）：

1．B．C．     2．A．     3．D．     4．D．     5．C． 

二、简答题（每题1分，共5分）

1．在求逻辑表达式值的过程中，一旦表达式的值能够确定，就不再逐步进行下面的运算。例如，假定a=2, b=0, c=3，逻辑表达式

a||b++||c--

因a为非0整数，表达式的值立即可以确定为true，后面的运算b++和c--不再进行，最后b仍为0，c仍为3。

2．    (1)构造函数无函数返回类型说明。

    (2)定义类时成员数据不分配内存，不可加存储类型说明。

    (3)析构函数是无参函数。

(4) 定义类时成员数据不分配内存，不可赋初值。

三、阅读程序段（每题5分，共20分）

1．分段与运费打折情况如下：

s<250                不打折扣

250<=s<500            2%折扣

500<=s<1000            5%折扣

1000<=s<2000        8%折扣

2000<=s<3000        10%折扣

3000<=s                15%折扣

输出结果：

运输单价：0.5     重量：40        里程：4300

折扣后运费：77900

2．Sum of 1*3 to 1*3 is 3

Sum of 1*3 to 2*3 is 9

Sum of 1*3 to 3*3 is 18

Sum of 1*3 to 4*3 is 30

3．勒让德多项式：

4．i=5  j=3

四、填空，完善程序（每空2分，共30分）

1．(1) x1=(x2+1)*2       (2)  x2=x1

   (3)  day—    

2．(4)  f(n)               (5)  n==1

   (6)  n*n+f(n-1)

3．(7)  a+=b            (8)  b=c

    (9)  c=d            (10)  d=a

    (11)  a+b+c+d

4．(12) i<=10                (13) j<=20

    (14)  100-10*i-5*j     (15) k>=0

C++程序设计试题（下）样卷（卷面60分）

（考试用时100分钟）

一、选择题（每题1分，共5分）

1．设计一个自定义类时，需要在屏幕上显示或向文件写入类对象的数据，最佳选择方法是       。

A．为屏幕显示和文件写入各自设计一个成员函数。

B．为屏幕显示和文件写入统一设计一个成员函数。

C．重载插入运算符（<<）。

D．重载提取运算符（>>）。

2．关于异常处理，那些说法是错误的             。

A．在C++程序中，由throw表达式抛出异常，而该表达式应直接或间接地被包含在try块中。

B．当抛出异常后，寻找匹配的catch子句有固定的过程：逆着程序函数的调用链返回，称为栈展开（Stack Unwinding）。

C．当某条语句抛出异常时，跟在其后的语句将被跳过，但析构函数仍然执行，所以应该在析构函数中释放资源。

D．catch子句实际是一个特殊的函数。

3．下列关于动态资源分配的说法中错误的是             。

A．动态分配的资源不仅包括内存，还包括文件。

B．动态内存分配的优点在于可以随时给数组分配所需的内存而不会失败。

C．动态分配的资源通常要求在析构函数中释放。

D．对含有动态分配的数据成员的类对象应该采用深复制。

4．下列有关模板的描述那些是错误的              。

A．模板把数据类型作为一个设计参数，称为参数化程序设计。

B．模板参数除模板类型参数外，还有非类型参数。

C．类模板与模板类是同一概念。

D．使用时，模板参数与函数参数相同，是按位置而不是名称对应的。

5．关于多态，下面那些说法是正确的               。

A．多态分静态的（编译时）和动态的（运行时）。

B．运行时的多态与类的层次结构有关。

C．在基类定义了虚函数后，在派生类中重新定义时可以不加关键字virtual。

D．仅使用虚函数并不能实现运行时的多态性，还必须采用指针或引用来调用才能真正实现运行时的多态性。

二、填空题（每空0.5分，共5分）

1．运算符重载时，其函数名由    （1）   构成。成员函数重载双目运算符时，左操作数是    （2）   ，右操作数是    （3）   。

2．C/C++中的数组用的是一个 （4）  的定义，即数组的基本定义是  （5）  构成的数组，三维数组的元素是  （6）  。

3．单链表的结点包含两个域：  （7） 和 （8） 。使用链表的最大的优点是 （9） ，即使是动态数组也做不到这一点。

4．纯虚函数定义时在函数参数表后加=0，它表明程序员对函数体不定义，其本质是将指向函数体的指针定为 （10） 。

三、阅读程序段（第一题4分，其余每题5分，共14分）

1．写出下面的程序输出的数据，这是什么图形？

int main(){

    int a[10][11]={0,1},i,j;

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

        for(j=1;j<=i+1;j++)    a[i][j]=a[i-1][j-1]+a[i-1][j];

    for(i=0;i<10;i++){

        for(j=1;j<=i+1;j++) cout<     cout<    }

    return 0;

}

2．写出下列程序的输出结果，并做简单的说明。

class Student{

    string coursename;                //课程名

    int classhour;                    //学时

    int credit;                        //学分

public:

    Student(){coursename="#";classhour=0;credit=0;}

    virtual void Calculate(){credit=classhour/16;}

    void SetCourse(string str,int hour){

        coursename=str;

        classhour=hour;

    }

    int GetHour(){return classhour;}

    void Print(){cout<<<"学分"<};

class GradeStudent:public Student{

public:

    GradeStudent(){};

    void Calculate(){SetCredit(GetHour()/20);}

};

int main(){

    Student s,*ps;

    GradeStudent g;

    s.SetCourse("英语80);

    g.SetCourse("英语80);

    ps=&s;

ps->Calculate();

ps->Print();

    ps=&g;

ps->Calculate();

ps->Print();

    return 0;

}

3．写出该程序的输出结果，并说明该类的定义中top和maxSize的意义。

templateclass Stack{

    int top; 

    T *elements; 

    int maxSize; 

public:

    Stack(int=30); 

    ~Stack(){delete[] elements;}

    void Push(const T &data); 

    T Pop();

};

template Stack::Stack(int maxs){

    maxSize=maxs;

    top=-1;

    elements=new T [maxSize]; 

}

template void Stack::Push(const T &data){

    elements[++top]=data; 

}

template T Stack::Pop(){

    return elements[top--];

}

int main(){

    int i;

    char a[5]={'k','c','a','t','s'};

Stackcstack();

    for(i=0;i<5;i++) cstack.Push(a[i]);

    for(i=0;i<5;i++) cstack.Pop());

    return 0;

}

四、填空，完善程序（每空2分，共36分）

1．对半查找递归算法，x为定值，算法作为升序有序表（ordered list）模板类的成员函数。其中T为模板类型参数，sixe代表有序表中数组slist元素的个数。小于比较运算符(<)在具体的类中重载。

template int Orderedlist::Binarysearch(T & x,const int low,const int high){ 

    int mid=-1; 

    if (low<=high){

        mid=(low+high)/2;

        if(slist[mid]        else if(x    }

    return       (3)    ;

}

2．冒泡排序算法，作为Orderedlist类的成员函数。last是有序表元素个数。

template void Orderedlist::BubbleSort(){

    bool noswap;   //交换标志

    int i,j;

    T temp;

    for (i=0;i        noswap=   (4)   ;

        for(j=   (5)   ;    (6)   ;   (7)   ){          //从下往上冒泡

            if(slist[j]                temp=slist[j];

                slist[j]=slist[j-1];

                slist[j-1]=temp;

                noswap=    (8)   ;

            }            

        }

        if(noswap) break; 

    }

}

3．用虚函数来实现辛普生法求函数的定积分。在梯形法中是用直线来代替曲边梯形的曲边，在辛普生法中是用抛物线来代替，得出的公式为（区间必须为偶数n个相等区间）。

class Simpson{

    double Intevalue,a,b;             //Intevalue积分值，a积分下限，b积分上限

public:

    virtual double fun(double x)=0;    //被积函数声明为纯虚函数

    Simpson(double ra=0,double rb=0){

        a=ra;

        b=rb;

        Intevalue=0;

    }

    void Integrate(){

        double dx;

        int i;

        dx=(b-a)/2000;

        Intevalue=     (9)     ;

        for(i=1;i<2000;i+=2)  Intevalue+=4*fun(     (10)     );

        for(i=2;i<2000;i+=2)  Intevalue+=2*fun(     (10)     );

        Intevalue*=dx/3;

    }

    void Print(){cout<<"积分值="<};

class A:public Simpson{

public:

    A(double ra,double rb):Simpson(ra,rb){};

    double fun(double x){     (11)     ;}    //以sin(x)作为被积函数

};

int main(){

    A a1(0.0,3.1415926535/2.0);

    Simpson *s=&a1;

s->Integrate(); //动态

s->Print();

    return 0;

}

4．单链表的结点采用类Node，以链表类List为友元类，List可直接访问Node的私有成员。对链表整体的操作则作为链表类的成员函数，这里列出向前生成链表、向后生成链表、创建结点等等。

templateclass Node{

    T info;                                     //数据域

Node *link; //指针域

public:

    ……

    friend class List;

};

templateclass List{

Node *head,*tail; //链表头指针和尾指针

public:

    ……

    void InsertFront(Node* p); //可用来向前生成链表，在表头插入一个结点

    void InsertRear(Node* p); //可用来向后生成链表，在表尾添加一个结点

Node*CreatNode(T data); //创建一个结点(孤立结点)

};

templatevoid List::InsertFront(Node *p){ //链头插入

p->link=     (12)     ;

         (13)    =p;

    if(tail==head) tail=p;

}

templatevoid List::InsertRear(Node *p){  //链尾插入

p->link=     (14)     ;

          (15)     =p;

    tail=p;

}

templateNode* List::CreatNode(T data){//建立新节点

Node*tempP=new Node(data);

    return tempP;

}

5．为学生类重载插入、提取和小于运算符。

class student{

    int key;

    string name;

public:

    bool operator<(student);

    friend ostream & operator<<(ostream & s,const student & k);

    friend istream & operator>>(istream & s,student & k);

};

ostream & operator<<(ostream & s,const student & k){

        （16）    ;

    return s;

}

istream & operator>>(istream & s,student & k){

         （17）   ;

    return s;

}

bool student::operator<(student st){return      （18）    ;}

答案：

一、选择题（每题1分，共5分）：

1．C．     2．D．     3．B．     4．C．     5．全部

二、填空题（每空0.5分，共5分）：

（1）关键字operator和重载的运算符 （2）对象

（3）该函数的参数               （4）递归

（5）数组                       （6）二维数组

（7）数据域                    （8）指针域

（9）用多少就开多少空间        （10）空指针

三、阅读程序段（第一题4分，其余每题5分，共14分）

1．输出如下：

   1

   1   1

   1   2   1

   1   3   3   1

   1   4   6   4   1

   1   5   10  10  5   1

   1   6   15  20  15  6   1

   1   7   21  35  35  21  7   1

   1   8   28  56  70  56  28  8   1

   1   9   36  84  126 126 84  36  9   1 

这是杨辉三角形。

2．输出如下：

英语80学时5学分

英语80学时4学分

   这是使用虚函数实现运行时的多态。第一行是本科生，第二行是研究生。

3．输出为：stack

   该类是栈，top是指向栈顶的指针，maxSize是栈的容量。

四、填空，完善程序（每空2分，共36分）

1．（1）mid+1,high

  （2）low,mid-1

（3）mid

2．（4）true

  （5）last

  （6）j>i

  （7）j--

  （8）false

3．（9）fun(a)+fun(b)

  （10）a+i*dx

  （11）return sin(x)

4．（12）head->link

  （13）head->link

  （14）tail->link

  （15）tail->link

5．（16）s<  （17）s>>k.key>>k.name;

  （18）keyC++程序设计(上)期终考试

上机考试样卷1

学号              姓名              成绩        

（考试时间60分钟，卷面分数30分）

说明：首先在Z盘建立一个以自己的学号命名的文件夹，用于保存上交的考试文件。对以下问题编制程序，调试运行，输出结果。

一、结构化程序                               （15分）

【

题目】利用级数展开式计算x的幂级数。

f(x)= (n≥0)

其中：g(m , x)= 

【要求】

(1) 主函数负责输入输出以及计算函数f(x)。从键盘输入x(-1(2) 为g(m,x)定义一个函数float fg(int m, float x)。主函数计算每项时必须调用此函数。

【注意】 将源程序以文件名MYF1.cpp存入Z盘自己的目录中。

二、面向对象程序                             （15分）

【

题目】日期计算程序

【要求】试建立一个类date用于描述日期对象，具体要求如下：

（1）私有数据成员

int year: 年

int month: 月 （此项也可使用枚举型）

int day: 日

（2）公有成员函数

    date ( ): 构造函数，初始化数据成员为默认值（均为1）。

date (…): 构造函数(自己定义参数)，用参数初始化数据成员。

    void set(…)：用给定的参数修改数据成员的值(自己定义参数)。

    void display( ): 打印输出该日期。

    void leapyear( )：通过计算判断该日期对象所在年份是否是闰年。

（3）在主程序中定义至少三个取值各不相同geome对象作为测试数据，完成对geome类和程序的测试。每个成员函数至少被调用一次。

【注意】 将源程序以文件名MYF2.cpp存入Z盘自己的目录中。

C++程序设计(上) 

上机考试样卷2

学号              姓名              成绩        

（考试时间60分钟，卷面分数30分）

说明：首先在Z盘建立一个以自己的学号命名的文件夹，用于保存上交的考试文件。对以下问题编制程序，调试运行，输出结果。

一、结构化程序                               （15分）

【

题目】判断降序数。（降序数是指该数的低位数字不大于高位数字，如74，853,666都是降序数，只有一位的数也是降序数）

【要求】

1.主函数负责输入输出。从键盘输入5个各不相同且不大于三位的正整数; 调用函数isdown( )判断这些数是否是降序数，输出判断结果信息。

2.定义一个函数int isdown (int x)，判断x是否是降序数，若是则返回1，否则返回0。

【注意】 将源程序以文件名MYF1.cpp存入Z盘自己的目录中。

二、面向对象程序                             （15分）

【题目】职工信息管理

【要求】试建立一个类worker用于描述职工对象，具体要求如下：

（1）私有数据成员

int id: 职工号。

char name[9]:姓名

float wage: 工资。（最低值为200）

char level: 技术等级（A—一等，B—二等，C—三等，其它为无级）

（2）公有成员函数

worker ( )：构造函数，初始化数据成员为默认值（数值型成员均为0，字符型成员为空值）。

worker (…)：构造函数(自己定义参数)，用参数初始化数据成员。

void List( ): 输出职工的各项信息。

void set( ): 从键盘输入新的数据，修改数据成员的值。接受输入前屏幕上显示提示输入哪些信息。

void addwage( ): 为职工增加工资并提升技术等级，从无级提至C级需增加30元，从C级提至B级需增加50元，从B级提至A级需增加100元。

（3）在主程序中定义三个worker对象作为测试数据，完成对worker类和程序的测试。每个成员函数至少被调用一次。

【注意】 将源程序以文件名MYF2.cpp存入Z盘自己的目录中。