OOP练习（6）

博学者普克尔特

于 2023-07-29 12:30:09 发布

阅读量481

点赞数

分类专栏：面向对象程序设计文章标签： c++ 学习

本文链接：https://blog.csdn.net/qq_68937706/article/details/131923828

版权

面向对象程序设计专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、判断题

1.Order of initialization in the initial list is the order of their declaration in the list.

T F

解析：F。初始化列表中的成员变量初始化顺序与它们在类中声明的顺序一致，而不是按照初始化列表中的顺序。

2.类的组合关系可以用“Has-A”描述；类间的继承与派生关系可以用“Is-A”描述。

T F

解析：T。“Has-A” 属于组合关系的表达形式，指一个类中包含另一个类的对象；而 “Is-A”属于继承关系，派生类对象也是一个基类对象，基类对象能够做的任何操作，派生类对象也能够做。

3.一个类的友元函数是这个类的成员。

T F

解析：F。友元函数不属于类，自然也不是类的成员。

4.在C++语言中引入内联函数（inline function）的主要目的是降低空间复杂度，即缩短目标代码长度。

T F

解析：F。引人内联函数的目的就是为了将少量多次使用的代码段进行重复利用，这样可以降低代码的长度，但是不能降低代码的空间复杂度。

5.主程序调用内联函数（inline）时，不发生控制转移，无需保存和恢复环境变量等，因此，节省了系统开销。内联函数的声明以及最终的生效，是由程序员决定的。

T F

解析：F。内联函数的声明以及最终生效，都是程序运行时自己做出的判断，而在编写程序时加上的inline只是对于内联函数的声明做出的建议。

二、单选题

1.一个函数功能不太复杂，但要求被频繁调用，可选用（）。

A.内联函数 B.重载函数 C.递归函数 D.嵌套函数

解析：A。内联函数产生的目的就是为了实现少量代码的多次重复调用。

2.在（）情况下适宜采用inline定义内联函数。

A.函数体含有循环语句

B.函数体含有递归语句

C.函数代码少、频繁调用

D.函数代码多、不常调用

解析：C。内联函数产生的目的就是为了实现少量代码的多次重复调用。

3.下面说法正确的是（）。

A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方

B.内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方

C.类的内联函数必须在类体内定义

D.类的内联函数必须在类体外通过加关键字inline定义

解析：B。内联函数运行的原理是在程序进行编译时将内联函数对应的目标代码插入每个调用该函数的地方。其既可以在类体内定义，也可以在类体外定义。

4.如果默认参数的函数声明为“ void fun(int a,int b=1,char c='a',float d=3.2);”，
则下面调用写法正确的是（）

A.fun(); B.fun(2,3); C.fun(2, ,'c',3.14); D.fun(int a=1);

解析：B。对于有缺省值的函数的调用，其在调用时为对变量进行从左到右赋值，没有赋缺省值的变量一定要调用时赋值，在此处，a未存在赋缺省值的情况，所以调用时需要给a赋值。然而，在赋值时我们不能跳过某个变量不进行赋值，必须从左到右进行赋值。

5.在C++中，关于下列设置缺省参数值的描述中，（）是正确的。

A.不允许设置缺省参数值；

B.在指定了缺省值的参数右边，不能出现没有指定缺省值的参数；

C.只能在函数的定义性声明中指定参数的缺省值；

D.设置缺省参数值时，必须全部都设置；

解析：B。对于有缺省值的函数的调用，其在调用时为对变量进行从左到右赋值，因此，我们在编写有缺省值的函数的时候，就必须将有缺省值的变量的右边均赋上缺省值。

6.决定C++语言中函数的返回值类型的是（）

A.return语句中的表达式类型

B.调用该函数时系统随机产生的类型

C.调用该函数时的主调用函数类型

D.在定义该函数时所指定的数据类型

解析：D。在定义函数时对函数的数据类型的定义，表明了该函数的返回值。

7.如有函数定义：void func(int x = 0, int y = 0){ …. }，则下列函数调用中会出现问题的是____。

A.func(1,2, 3);

B.func(1,2);

C.func(1);

D.func();

解析：A。因为相应的函数只有两个变量，如果赋给了三个值的话，会出现赋值错误而报错。

8.以下选项中，是正确的函数默认形参设置的是。

A.int fun(int a,int b,int c);

B.int fun(int a,int b,int c=1);

C.int fun(int a,int b=1,int c);

D.int fun(int a=1,int b,int c);

解析：B。由于要求在编写有缺省值的函数的时候，赋了缺省值的变量右侧不能有未赋缺省值的变量，故仅B符合要求。

9.对于以下关于友元的说法

A.如果函数fun被声明为类A的友元函数，则该函数成为A的成员函数

B.如果函数fun被声明为类A的友元函数，则该函数能访问A的保护成员，但不能访问私有成员

C.如果函数fun被声明为类A的友元函数，则fun的形参类型不能是A。

D.以上答案都不对

解析：D。类A的友元函数不是类A的成员变量，但是友元函数有权限访问类中的所有成员变量，不存在不能访问私有成员的情况。而其为A的友元函数和其本身的形参数据类型没有关系，完全可以把形参设置为A类。

10.对于类之间的友元关系：

A.如果类A是类B的友元，则B的成员函数可以访问A的私有成员

B.如果类A是类B的友元，则B也是A的友元。

C.如果类A是类B的友元，并且类B是类C的友元，则类A也是类C的友元。

D.以上答案都不对。

解析：D。A类是B类的友元，则为A类的成员函数可以访问B类的所有成员变量。类之间的友元不具有双向性，也不具有传递性。

11.友元的作用是

A.提高程序的运用效率

B.加强类的封装性

C.实现数据的隐藏性

D.增加成员函数的种类

解析：A。友元方便了不同类中的函数对变量的访问，减少了繁琐的调用过程，提高了程序的运行效率。

12.下面关于友元的描述中，错误的是：

A.友元函数可以访问该类的私有数据成员

B.一个类的友元类中的成员函数都是这个类的友元函数

C.友元可以提高程序的运行效率

D.类与类之间的友元关系可以继承

解析：D。友元关系是不能被继承的。

13.已知类A是类B的友元，类B是类C的友元，则：

A.类A一定是类C的友元

B.类C一定是类A的友元

C.类C的成员函数可以访问类B的对象的任何成员

D.类A的成员函数可以访问类B的对象的任何成员

解析：D。友元没有双向性和传递性，故仅有D为正确。

14.不属于类的成员函数的是（）。

A.构造函数 B.析构函数 C.友元函数 D.复制构造函数

解析：C。友元函数不是类的成员函数。

15.若类A被说明成类B的友元，则（）。

A.类A的成员即类B的成员

B.类B的成员即类A的成员

C.类A的成员函数不能访问类B的成员

D.类B不一定是类A的友元

解析：D。友元函数是具有访问变量的权限，而并不是说明就是对应类的成员。因为类A是类B的友元，则类A可以访问类B的所有成员变量。然而，友元不具有相互性，故B不一定为A的友元函数。

16. 在下列关键字中,用以说明类中公有成员的是（）。

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

解析：A。说明公有变量的关键字为public。

17.Suppose a class is defined without any keywords such as public, private and protected，all members default to

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

解析：C。未加关键词修饰的变量的类型为private。

18.Who can access a private member of a class?

A.Only member functions of that class.

B.Only member functions of that class and friend functions or member functions of friend classes

C.Only member functions of that class and derived classes

D.None of the others

解析：B。只有在本类中的成员函数和友元函数可以访问一个类中的私有成员变量。

19.静态成员函数没有：

A.返回值 B.this指针 C.指针参数 D.返回类型

解析：B。静态成员是类具有的属性，不是对象的特征，而this表示的是隐藏的对象的指针，因此静态成员函数没有this 指针。

20.For the code below:

class A {
  static int i;
  //...
};

Which statement is NOT true?

A.All objects of class A reserve a space for i

B.All objects of class A share the space of i

C.i is a member variable of class A

D.i is allocated in global data space

解析：A。静态变量属于类，在整个程序全局中只会有一个同名静态变量，所有的i共用一个存储位置。

三、函数题

1.复数的加减运算

###复数加减（友元的应用）

声明一个复数类CComplex（类私有数据成员为double型的real和image）
定义构造函数，用于指定复数的实部与虚部。
定义成员函数，调用该函数时，以格式real+image i的格式输出当前对象（当虚部为正数时，实部虚部中间用+号连接，当虚部为复数时，实部虚部用-号连接）。
编写加法友元函数，以复数对象c1, c2为参数，求两个复数对象之和（实部虚部分别相加）。
编写减法友元函数，以复数对象c1, c2为参数，求两个复数对象的差（实部虚部分别相减）

输入格式:
输入有两行：
第一行是复数c1的实部与虚部，以空格分隔；
第二行是复数c2的实部与虚部，以空格分隔。

输出格式:
输出共四行:
第一行是c1；
第二行是c2；
第三行是c1与c2之和；
第四行是c1与c2之差；

函数接口定义：

在这里描述类定义
class CComplex{...}

裁判测试程序样例：

int main()
{
  double r1,r2,i1,i2;
    cin>>r1>>i1;
    cin>>r2>>i2;
    CComplex c1(r1,i1),c2(r2,i2),c3,c4;
    c1.display();
    c2.display();
    c3=add(c1,c2);
    c3.display();
    c4=    sub(c1,c2);
    c4.display();
}

/* 请在这里填写答案 */

输入样例：

10 20
30 40

输出样例：

10+20i
30+40i
40+60i
-20-20i

代码解答：

class CComplex
{ 
public:
    CComplex()
    {
        real = 0.0;
        imag = 0.0;
    }
    CComplex(double real, double imag)
    {
        this->real = real;
        this->imag = imag;
    }
    void display()
    {
        string i = "i";
        if (imag >= 0)
        {
            cout << real << "+" << imag << i << endl;
        }
        else
        {
            cout << real << imag << i << endl;
        }
    }
private:
    double real, imag;
    friend CComplex add(CComplex &a, CComplex &b)
    {
        CComplex c;
        c.real = a.real + b.real;
        c.imag = a.imag + b.imag;
        return c;
    }
    friend CComplex sub(CComplex& a, CComplex& b)
    {
        CComplex c;
        c.real = a.real - b.real;
        c.imag = a.imag - b.imag;
        return c;
    }
};

2.函数重载实现两数相加

设计一个重载函数add，该函数有两个参数，可以实现两个类型相同的参数相加的操作，函数返回相加的结果。两个参数可以是整数、实数和字符串，但必须保证两个参数类型相同。

裁判测试程序样例：

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

/* 请在这里填写答案 */


int main()
{
    int a, b;
    double c, d;
    string s1, s2;

    cin >> a >> b;
    cin >> c >> d;
    cin >> s1 >> s2;

    cout << add(a, b) << endl;
    cout << fixed << setprecision(2) << add(c, d) << endl;
    cout << add(s1, s2) << endl;

    return 0;
}

输入样例：

3 5
3.3333 5.555555
hello world

输出样例：

8
8.89
helloworld

代码解答：

int add(int a, int b){
    return a+b;
}

double add(double a,double b){
    return a+b;
}

string add(string a,string b){
    return a+b;
}

3.带默认形参值的函数

设计一个带默认形参值的函数add，该函数有三个参数，可以实现三个整数类型的参数相加的操作，函数返回相加的结果。默认形参值从右至左分别是30、20。

裁判测试程序样例：

#include <iostream>
using namespace std;

/* 请在这里填写答案 */


int main()
{
    int a, b, c;

    cin >> a >> b >> c;

    cout << add(a) << endl;
    cout << add(a, b) << endl;
    cout << add(a, b, c) << endl;

    return 0;
}

输入样例：

1 2 3

输出样例：

51
33
6

代码解答：

int add(int a ,int b = 20,int c = 30){
    return a + b + c;
}

四、程序题

1.统计英文单词个数

给出一篇英文文章，现在需要统计文章中出现英文单词的数量。

输入格式:

第一行一个T，代表数据组数

对于每组数据，第一行一个n，代表文章中单词的个数，其后n行每行一个只包含小写字母的长度为1到10的字符串

输出格式:

每组数据输出若干行，每行输出单词以及它出现的次数（中间空格隔开），不同单词按单词字典序从小到大输出

保证单词出现的总次数<=1e5

输入样例:

1
8
it
is
a
pen
it
is
a
dog

输出样例:

a 2
dog 1
is 2
it 2
pen 1

代码解答：

#include<bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <map>
#include <string>
using namespace std;

int main() {
	string s;
	int t,n;
	map<string,int> m;
	map<string,int>::iterator it;
	cin>>t;
	while(t--) {
		cin>>n;
		m.clear();//不要忘了 
		while(n--) {
			cin>>s;
			m[s]++;
		}
		for(it=m.begin(); it!=m.end(); it++)
			cout<<it->first<<" "<<it->second<<endl;
	}
	return 0;
}

2.众数

给出若干个正整数，请找出出现次数最多的数。

输入格式:

在一行中输入若干个数，以空格间隔（读入数的总个数不超过5000）。

输出格式:

输出出现次数最多的数（若答案不唯一，输出最小的那个）。

输入样例:

在这里给出一组输入。例如：

18 999 999 2100000000

输出样例:

在这里给出相应的输出。例如：

代码解答：

#include<iostream>
#include<map>
#include<string>
using namespace std;
int main()
{
    int x;//暂存出入
    map<int,int> mp;//map容器，int指向int
    map<int,int> ::iterator it;//迭代器
    while(cin>>x)
    {
        mp[x]++;
    }
    int min=mp.begin()->first;
    for(it=mp.begin();it!=mp.end();it++)
    {
        if(it->second >= mp[min])
        {
           if(min>it->first) //输出较小的那个
           			min=it->first;
        }  
    }
    cout<<min;//输出出现最多并且较小的数
    return 0;
}