2017 程序设计实习之C++部分作业题汇总 - B：面向对象基础

题目来源：2017 程序设计实习之C++部分作业题汇总

1、B01:编程填空：学生信息处理程序

总时间限制: 1000ms 内存限制: 1024kB
描述
实现一个学生信息处理程序，计算一个学生的四年平均成绩。

要求实现一个代表学生的类，并且类中所有成员变量都是【私有的】。

补充下列程序中的 Student 类以实现上述功能。

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <cstdlib>
using namespace std;

class Student {
// 在此处补充你的代码
private:
    string name_m;
    int age_m;
    int id_m;
    int grade_1_m;
    int grade_2_m;
    int grade_3_m;
    int  grade_4_m;
    double aver_m;   //明确提到平均成绩可能不是整数
public:
    //可以使用默认的无参构造函数，反正什么也没做，mian要求的三个函数为public
    void input()
    {
        string s;
        getline(cin, s);
        //设置t作为序号，按序提取每一项，共7项
        int t = 1;
        while (!s.empty())
        {
            int pos = s.find_first_of(',');
            switch (t)
            {
            case 1:
                name_m = s.substr(0, pos);
                break;
            case 2:
                age_m = atoi(s.substr(0, pos).c_str());
                break;
            case 3:
                id_m = atoi(s.substr(0, pos).c_str());
                break;
            case 4:
                grade_1_m = atoi(s.substr(0, pos).c_str());
                break;
            case 5:
                grade_2_m = atoi(s.substr(0, pos).c_str());
                break;
            case 6:
                grade_3_m = atoi(s.substr(0, pos).c_str());
                break;
            case 7:
                grade_4_m = atoi(s.c_str());
                pos = -1;
                s = "";
                //case7需要额外处理，因为break后有s = s.substr(pos + 1)，然而case7时pos的值因为找不到','而不可用
                //将s清空，pos为-1，s = s.substr(pos + 1)会从pos+1的位置一直到s的末尾截取s的子串作为s使s = ""
                //当s = ""时s.empty()为true，退出while循环
                break;
            }
            //每提取出一项后，s的值动态更新，以便提取下一项，用t来标记每一项的序号
            s = s.substr(pos + 1);
            t++;
        }       
    }
    void calculate()
    {
        aver_m = grade_1_m + grade_2_m + grade_3_m + grade_4_m;
        aver_m /= 4;
    }
    void output()
    {
        cout << name_m << "," << age_m << "," << id_m << ","
            << aver_m << endl;
    }
//end of my code
};

int main() {
    Student student;        // 定义类的对象
    student.input();        // 输入数据
    student.calculate();    // 计算平均成绩
    student.output();       // 输出数据
}

输入
输入数据为一行，包括：
姓名,年龄,学号,第一学年平均成绩,第二学年平均成绩,第三学年平均成绩,第四学年平均成绩。
其中姓名为由字母和空格组成的字符串（输入保证姓名不超过20个字符，并且空格不会出现在字符串两端），年龄、学号和学年平均成绩均为非负整数。信息之间用逗号隔开。
输出
输出一行数据，包括：
姓名,年龄,学号,四年平均成绩。
信息之间用逗号隔开。
样例输入
Tom Hanks,18,7817,80,80,90,70
样例输出
Tom Hanks,18,7817,80
提示
必须用类实现，其中所有成员变量都是私有的。
输出结果中，四年平均成绩不一定为整数。

2、B02:Apple

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空，使其输出4 5 1

#include <iostream>
using namespace std;
class Apple {
// 在此处补充你的代码
private:
    static int nTotalNumber;
public:
    Apple() { ++nTotalNumber; }
    Apple(const Apple & a) { }
    ~Apple() { --nTotalNumber; }
//end of my code
static void PrintTotal() {
        cout << nTotalNumber << endl; //结论1：nTotalNumber为静态变量成员
    }

};
int Apple::nTotalNumber = 0;
Apple Fun(const Apple & a) {
    a.PrintTotal();
    return a;
}
int main()
{
    //分析mian执行的过程：
    //1.无参构造函数生成4个对象，进入Fun，输出nTotalNumber = 4
    //2.退出Fun，复制构造函数生成1个对象并返回到mian中成为临时对象，语句执行完成，临时对象析构
    //3.无参构造函数生成2个对象，输出nTotalNumber = 5
    //4.析构new出来的4个对象，输出nTotalNumber = 1
    Apple * p = new Apple[4];
    Fun(p[2]);           //output 4
    Apple p1,p2;
    Apple::PrintTotal ();//output 5
    delete [] p;
    p1.PrintTotal ();    //output 1
    return 0;
    //得到结论：
    //1.无参构造函数中nTotalNumber自增1
    //2.析构函数中nTotalNumber自减1
    //3.复制构造函数没有对nTotalNumber操作
}

输入
无
输出
4
5
1
样例输入
None
样例输出
4
5
1
来源
Guo Wei

3、B03:奇怪的类复制

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空，使其输出9 22 5

#include <iostream>
using namespace std;
class Sample {
public:
    int v;
// 在此处补充你的代码
    Sample(int n = 0):v(n){}
    Sample(const Sample & rhs):v(rhs.v + 2){}
//end of my code
};
void PrintAndDouble(Sample o)
{
    cout << o.v;
    cout << endl;
}
int main()
{
    //分析mian执行的过程：
    //1.一个int型参数的有参构造函数生成对象a，复制构造函数用a初始化b
    //2.PrintAndDouble的参数是类对象，调用复制构造函数初始化形参
    //3.类型转换构造函数初始化c，无参构造函数初始化d，a赋值给d
    //可以使用默认的赋值运算符重载，成员变量只有int，浅复制足以满足需求
    Sample a(5);
    Sample b = a;
    PrintAndDouble(b);//output 9
    Sample c = 20;
    PrintAndDouble(c);//output 22
    Sample d;
    d = a;
    cout << d.v;//output 5
    return 0;
    //得到结论：
    //1.由d = a，有参构造函数将参数赋值给v
    //2.复制构造函数用a初始化b，再用b初始化o，由5得到9，即通过两次相同的运算5->x->9
    //3.类型转换构造函数,根据参数20搜索构造函数列表，用有参构造函数生成一个临时对象并赋值给c，故c.v = 20
    //根据5->x->9 和 20->22,复制构造函数的动作明确，被初始化的对象的v比作为参数的对象的v大2
}

输入
无
输出
9
22
5
样例输入
None
样例输出
9
22
5
来源
Guo Wei

4、B04:返回什么才好呢

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空，使其按要求输出

#include <iostream>
using namespace std;
class A {
public:
    int val;

    A(int
// 在此处补充你的代码
    n = 123) : val(n){}
    int & GetObj(){     return val; }
    operator int(){     return val; }
//end of my code
};
int main()
{
    //分析mian执行的过程：
    //1.无参构造函数，将val的值设为123
    //2.GetObj()的返回值类型是引用，不然无法当左值，根据m赋值给了val，所以应该返回val
    //3.有参构造函数将参数传给v，所以可以用int型的默认参数合并有参构造函数和无参构造函数
    //A(n)作为一个匿名的临时对象，需要赋值给一个int型的变量，需要类型转换，重载operator int()，返回其val
    int m,n;
    A a;
    cout << a.val << endl;
    while(cin >> m >> n) {
        a.GetObj() = m;
        cout << a.val << endl;
        a.GetObj() = A(n);
        cout << a.val<< endl;
    }
    return 0;
}

输入
多组数据，每组一行，是整数 m 和 n
输出
先输出一行：
123
然后，对每组数据，输出两行，第一行是m,第二行是n
样例输入
2 3
4 5
样例输出
123
2
3
4
5
来源
Guo Wei

5、B05:第四周程序填空题1

总时间限制: 1000ms 内存限制: 65536kB
描述
下面程序的输出是：

3+4i

5+6i

请补足Complex类的成员函数。不能加成员变量。

#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Complex {
private:
    double r,i;
public:
    void Print() {
        cout << r << "+" << i << "i" << endl;
    }
// 在此处补充你的代码
//include中提供了cstring，没有string，参数类型为const char * pstr
    Complex& operator=(const char *pstr)
    {
        /************************************************
        *** 根据实际的参数，这个判断根本就用不到，然而还是写习惯了
        if (pstr == nullptr)
        {
            r = 0;
            i = 0;
            return *this;
        }
        *************************************************/
        int pos1 = 0, pos2 = 0;
        int len = strlen(pstr);
        for (int i = 0; i < len; ++i)
        {
            if (pstr[i] == '+')
                pos1 = i;
            else if (pstr[i] == 'i')
                pos2 = i;
        }
        //+前面的是r，+与i(字符)之间的是i(变量成员)，接下来就可以分离r与i，再用stdlib的atof取出
        char *p1 = new char[len];
        char *p2 = new char[len];
        memcpy(p1, pstr, pos1*sizeof(char));//复制pstr的0到pos1 - 1共pos1个字节到p1
        p1[pos1] = '\0';                    //设置p1的合法末尾
        //复制pstr的pos1+1到pos2-1共pos2 - pos1 - 1个字节到p2
        memcpy(p2, pstr + pos1 + 1, (pos2 - pos1 - 1)*sizeof(char));
        p2[pos2 - pos1 - 1] = '\0';         //设置p2的合法末尾
        r = atof(p1);
        i = atof(p2);
        delete[]p1;//new 申请的内存空间不再使用的时候要及时释放，以免memory leak
        delete[]p2;
        return *this;
    }
    //end of my code
};
int main() {
    //分析mian执行的过程：
    //1.无参构造函数，好像也没做什么
    //2.a = "3+4i"，显然需要重载赋值运算符，有两种思路：
    //2.1: operator =(const char * pstr)
    //2.2: operator =(const Complex & rhs),需要先提供Complex(const char *pstr)的类型转换构造函数，所以选择思路1任务量比较合理
    Complex a;
    a = "3+4i"; a.Print();
    a = "5+6i"; a.Print();
    return 0;
}

输入
无
输出
3+4i
5+6i
样例输入
None
样例输出
3+4i
5+6i

6、B06:MyString

总时间限制: 1000ms 内存限制: 65536kB
描述
补足MyString类，使程序输出指定结果

#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class MyString {
    char * p;
public:
    MyString(const char * s) {
        if( s) {
            p = new char[strlen(s) + 1];
            strcpy(p,s);
        }
        else
            p = NULL;
    }
    ~MyString() { if(p) delete [] p; }
// 在此处补充你的代码
    MyString (const MyString & rhs)
    {
        if (rhs.p == NULL)
            p = NULL;
        else
        {
            p = new char[strlen(rhs.p) + 1];
            strcpy(p, rhs.p);
        }       
    }
    //实现以类对象的引用为参数的赋值运算符重载函数
    MyString & operator=(const MyString & rhs)
    {
        if (this == &rhs)
            return *this;
        if (p)
            delete[]p;
        p = new char[strlen(rhs.p) + 1];
        strcpy(p, rhs.p);
        return *this;
    }
    //以const char * pstr 为参数的赋值运算符重载函数
    //可以委托以类对象的引用为参数的赋值运算符重载函数予以处理
    MyString & operator=(const char * pstr)
    {
        MyString temp(pstr);
        return *this = temp;
    }
    //Copy也委托
    //step1：类型转换构造函数生成临时对象
    //step2：临时对象委托以类对象的引用为参数的赋值运算符重载函数完成功能，体现代码复用关系
    void Copy(const char *pstr)
    {
        *this = pstr;
    }
    friend ostream &operator<<(ostream & os,const MyString & rhs)
    {
        os << rhs.p;
        return os;
    }
//end of my code
};
int main()
{
    //分析mian执行的过程：
    //1.有参构造函数，参数为const char * s，在已给出的code里面已实现
    //2.复制构造函数
    //3.public属性的Copy函数，参数为类对象或类对象的引用(推荐)
    //4.赋值运算符，参数分别有4.1 类对象 : s2 = s1
    //                     4.2 const char * s : s2 = w2;
    //5.<< 运算符的重载
    char w1[200],w2[100];
    while( cin >> w1 >> w2) {
        MyString s1(w1),s2 = s1;
        MyString s3(NULL);
        s3.Copy(w1);
        cout << s1 << "," << s2 << "," << s3 << endl;

        s2 = w2;
        s3 = s2;
        s1 = s3;
        cout << s1 << "," << s2 << "," << s3 << endl;

    }
}

输入
多组数据，每组一行，是两个不带空格的字符串
输出
对每组数据，先输出一行，打印输入中的第一个字符串三次
然后再输出一行，打印输入中的第二个字符串三次
样例输入
abc def
123 456
样例输出
abc,abc,abc
def,def,def
123,123,123
456,456,456
来源
Guo Wei

7、B07:Big & Base 封闭类问题

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空，输出指定结果

#include <iostream>
#include <string>
using namespace std;
class Base {
public:
    int k;
    Base(int n):k(n) { }
};
class Big
{
public:
    int v;
    Base b;
// 在此处补充你的代码
    //封闭类需要在初始化列表中执行成员对象的构造函数
    //封闭类在复制构造函数中也需要执行对象成员的复制构造函数
    Big(int n):v(n),b(n){}
    Big(const Big & rhs):v(rhs.v),b(rhs.b){}
// end of my code
};
int main()
{
    //分析mian执行的过程：
    //1.封闭类的有参构造函数，参数为const int n
    //2.封闭类的复制构造函数
    //3.显然根据输出结果，有参构造函数的参数先被赋值给v，然后作为Base类有参构造函数的参数赋值给b.k
    //封闭类的复制构造函数，在初始化列表中调用成员对象的复制构造函数即可
    int n;
    while(cin >>n) {
        Big a1(n);
        Big a2 = a1;
        cout << a1.v << "," << a1.b.k << endl;
        cout << a2.v << "," << a2.b.k << endl;
    }
}

输入
多组数据，每组一行，是一个整数
输出
对每组数据，输出两行，每行把输入的整数打印两遍
样例输入
3
4
样例输出
3,3
3,3
4,4
4,4
来源
Guo Wei