2023秋--重庆大学cpp期末模拟检测参考答案

青天井Aotenjou

于 2023-12-22 19:31:06 发布

阅读量2.1k

点赞数 39

文章标签： c++

本文链接：https://blog.csdn.net/2302_79915950/article/details/135159039

版权

选择题：

1.下列程序代码，正确的输出结果是（ C）

int a=0xfe;
char b=062;
cout<<a<<","<<b<<endl;

A.0xfe,062
B.fe,62
C.254,2
D.254,62

解析：0xfe是十六进制数。转换为10进制为254；062有前导零，C++中认为是八进制数，以数字0开头的整数常量被视为八进制数。cout输出char类型，会输出变量字符类型，即ASCII形式。062换算为10进制为50，50对应字符2。

2.下列代码能正确执行的是（ A）
A.
char a='C';
const char& p=a;

B.
char a='C';
char* const p;
p=&a;

C.
char a='C';
const char& p;
p=a;

D.
char a='C';
char& p;
p=a;

解析：选项均将字符类型变量初始化为C。

对于B，p为指针常量，不能修改p本身的值（*p=&a合法，可以修改指针指向的字符）（区分指针常量和常量指针）。

对于C，const char& p是一个常量引用，即不能用p=a表示对常量引用p的初始化。正确的方式是在声明时进行初始化，即const char& p=a。

对于D，与C类似。

3.new和delete运算符正确的使用是（ C）

A.
int* p=new int[10];
delete p;

B.
int* p=new int(10);
delete []p;

C.
vector<int>* v=new vector<int>[10];
delete []v;

D.
int* a=new int[]{1,2,3,4};
delete []a;

解析：

对于A，p是指向数组的指针。删除应用delete[]p

对于B，与A相反。

对于D，对a的初始化不合法。（有争议，C++11后，D是正确的）

4.下列哪个代码能够实现x和y值的交换（B ）

A.
void fun(int a,int b) {
int x = a;
a = b;
b = x;
}
int main() {
int x = 1, y = 2;
fun(&x, &y);fun函数为值传递，此处传递的是x y的副本，不改变x y的值
cout << x << ","<<y << endl;
return 0;
}

B.
void fun(int* a,int* b) {
int x = *a;
*a = *b;
*b = x;
}
int main() {
int x = 1, y = 2;
fun(&x,&y);
cout << x << ","<<y << endl;
return 0;
}

C.
void fun(int& a,int& b) {
int x = a;
a = b;
b = x;
}
int main() {
int x = 1, y = 2;
fun(&x, &y);同A
cout << x << ","<<y << endl;
return 0;
}

D.
void fun(const int&a,const int&b) {//常值引用，无法改变值
int x = a;
a = b;//这两处不合法
b = x;//
}
int main() {
int x = 1, y = 2;
fun(x, y);
cout << x << ","<<y << endl;
return 0;
}

5.下面有一个结构体，对结构体的错误使用是（ B）

struct Book{
string name;
double price;
}

A.
Book b{"C++",20};

B.
Book b;
b->name="C++";
b->price=20;应用b.来访问name，price。->一般用于指向结构体、类的实例的指针

C.
Book *b=new Book[2];
b[0].name="C++";
b[0].price=20;

D.
Book *p=new Book();
p->name="C++";
p->price=20;

6.下列种类的函数中，哪一种不是类的成员函数？(C)
A.
构造函数
B.
析构函数
C.
友元函数\\基础概念
D.
拷贝构造函数

7.父类Base和子类Derive的定义如下。请问在子类中，继承的父类成员f，x，y的访问控制权限分别是：D

class Base
{
public:
void f();
protected:
int x;
private:
int y;
};

class Derive : protected Base{};

A.
public, protected, private
B.
public, public, public
C.
private, private, private
D.
protected, protected, private

三种继承：

1.public：继承父类的public，protected。且继承属性不变。

2.protected：继承父类的public，protected。且继承属性均为protected。

3.private：继承父类的public，protected。且继承属性均为private。

8.当变量x的输入值是9时，下面程序的运行结果是：C

#include <iostream>
#include <string>
using namespace std;
int main()
{
    int x;
    cin>>x;
    try
    {
        cout<<"begin"<<endl;
        if(x>100)
        {
            cout<<"1"<<endl;
            throw string("too big.");
        }
        else
        {
            cout<<"x="<<x<<endl;
        }
        cout<<"2"<<endl;
    }
    catch(string e)
    {
        cout<<"3:"<<e<<endl;
    }
    cout<<"end"<<endl;
    return 0;
 }

A.
begin

end

B.
begin

3: too big.

end

C.
begin

x=9

end

D.
begin

3: too big.

end

基础概念。

9.下列哪个代码不会调用对象的拷贝构造函数（C ）

A.
MyClass a;
MyClass b=a;

B.
MyClass a;
MyClass b(a);

C.
MyClass a;
MyClass& b=a;\\引用 b 不会触发拷贝构造函数的调用。它只是一个别名，指向同一个对象 a。因此，不会发生对象的复制。

D.
void f(MyClass obj)
{
....
}
MyClass a;
f(a);

10.根据下列类模板声明，正确初始化对象的方式是（ A）

template<typename T1, typename T2>
class MyClass{
private:
T1 x;
T2 y;
public:
MyClass(T1 _x, T2 _y):x(_x),y(_y){}
};

A.
MyClass<int,char> a(10,'a');

B.
MyClass a(10,'a');

C.
MyClass<int,char> a;

D.
MyClass a;

解析：

根据类模板的声明，MyClass 是一个带有两个模板参数的类模板，分别为 T1 和 T2。在选项 A 中，使用了具体的类型实参 int 和 char，将 T1 实例化为 int，将 T2 实例化为char。

在构造函数中，通过初始化列表对成员变量 x 和 y 进行初始化。因此，选项 A 中的初始化方式是正确的，它使用了正确的类型实参，并通过初始化列表对成员变量进行初始化。

选项 B、C 和 D 都没有提供类型实参，无法实例化类模板。不正确。

函数题：

6-1 类的定义（教师类Teacher）：本题要求定义一个教师类Teacher，数据成员包含姓名name和年龄age，类的声明见给出的代码，请给出类的完整实现，并通过测试程序。

Teacher::Teacher(string n,int a){\\基础题
    name=n;
    age=a;
}
string Teacher::getName() const{
    return name;
}
int Teacher::getAge() const{
    return age;
}
void Teacher::setName(string n)
{
    name =n;
}
void Teacher::setAge(int a)
{
    age =a;
}

6-2 加、不等和输入输出的运算符重载（2维向量Vec2）
本题要求定义一个二维向量类Vec2，类的声明见给出的代码，请给出类的完整实现，并通过测试程序。类的声明包括如下内容：

数据成员，向量的第一维u和第二维v；
u和v的访问函数；
构造函数；
加号、减号运算符重载（遵守二维向量的运算规则）；
==和!=运算符重载（遵守二维向量的运算规则）
输入、输出运算符重载。

Vec2::Vec2(double a,double b){\\其实与上题name，age初始化是一样的
    u=a;
    v=b;
}
Vec2 Vec2::operator+(const Vec2&b)
\\重载加法，原先的Vec2的u v分别与新的b的u v相加。（左值与右值）
{
    return Vec2(b.u+u,b.v+v);
}
bool operator!=(const Vec2&a,const Vec2&b) \\不等，其实可以照抄那个==
{
    return a.u!=b.u&&a.v!=b.v;
}
ostream&operator<<(ostream&os,const Vec2&c)\\重载输出流，对着题目照葫芦画瓢
{
    os<<"u="<<c.u<<",v="<<c.v;
}
istream&operator>>(istream&is,Vec2&c)\\输入流也是
{
    is>>c.u>>c.v;
}

6-3 继承和多态（水果和香蕉）
请设计水果和香蕉类，并通过测试程序，具体要求如下：

水果（Fruit）是基类，成员包含：
保护成员变量重量（weight，int类型）
公有构造函数
公有析构函数
公有函数display
香蕉（Banana）从水果类公有继承，成员包含：
私有成员变量产地（origin，string类型）
公有构造函数
公有析构函数
公有函数display

class Fruit
{
    protected:
    int weight;
    public:
    Fruit()
    {
        cout<<"Fruit Constructor"<<endl;\\构造
    }
    Fruit(int w)
    {
        weight=w;
        cout<<"Fruit Constructor"<<endl;\\含参构造
        
    }
    virtual ~Fruit()
    {
        cout<<"Fruit Destructor"<<endl;\\析构，防止与子类冲突用virtual
    }
    virtual void display()\\同上。（为了满足题意）
    {
        cout<<"weight="<<weight<<endl;

    }
};
class Banana:public Fruit
{
    private:
    string origin;
    public:
    Banana(){};
    Banana(string o,int w)
    {
        Fruit::weight=w;
        origin=o;
        cout<<"Banana Constructor"<<endl;
    }
    ~Banana()
    {
        cout<<"Banana Destructor"<<endl;
    }
    void display()
    {
        cout<<"origin="<<origin<<",weight="<<weight<<endl;
    }
};

编程题：

7-1 约数
当整数a除以整数b(b≠0)，除得的商正好是整数而没有余数时，称b是a的约数。给你两个正整数A和B, 如果B是A的约数，请打印输出A+B, 否则打印输出A−B。

#include<iostream>
#include<cmath>
using namespace std;
int main(){
    int A,B;
    cin>>A>>B;
    if(A%B==0)
    {
        cout<<A+B;
    }
    else
    {
        cout<<A-B;
    }
}

7-2 逆序整数

#include<iostream>
#include<cmath>
#include<string>
using namespace std;
int main(){
    int n,cnt=0;
    cin>>n;
    string x,y;\\用字符串实现
    cin>>x>>y;
    for(int i=0;i<n;i++)
    {
        if(x[i]!=y[n-i-1])
        {
            cnt++;
        }
    }
if(cnt>0)
{
    
    cout<<x<<" and "<<y<<" are not reverse.";
}
if(cnt==0)
    {
    cout<<x<<" and "<<y<<" are reverse.";
    }
}

7-3 一维世界的疫情传播

#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main(){
    int N,M,X,Y;
    int xmax=-101,xmin=101,ymax=-101,ymin=101;
    cin>>N>>M>>X>>Y;
    vector<int>xi(N);
    vector<int>yi(M);
    for(int i=0;i<N;i++)
    {
        cin>>xi[i];
        if(xi[i]>xmax)
        {
            xmax=xi[i];
        }
        if(xi[i]<xmin)
        {
            xmin=xi[i];
        }
    }
    for(int i=0;i<M;i++)
    {
        cin>>yi[i];
        if(yi[i]>ymax)
        {
            ymax=yi[i];
        }
        if(yi[i]<ymin)
        {
            ymin=yi[i];
        }
    }
    xmax=max(X,xmax);
    xmin=min(X,xmin);
    ymax=max(Y,ymax);
    ymin=min(Y,ymin);

if(ymax<xmin||xmax<ymin)
{
    cout<<X<<" and "<<Y<<": impossible";
}
else
{
    cout<<X<<" and "<<Y<<": possible";
}
}

解析：首先确定x，y的活动范围。因为参数均在[-100,100]，用xmax，xmin，ymax，ymin找到感染者与正常者的活动区域的边界。再与他们的家比较，得到活动范围。如果，其中一个范围的最大值小于另一个范围的最小值，则可以认为两个范围没有重叠。