C++ | 湖北工业大学2022年卷子

改错题

①

~Date(){delete *this} //改写：~Date(){delete this}

 

  

 ②

 ③

 正确写法：operator long()const;

类型转换函数

1. 作用
类对象转换成另一类型数据

2. 格式

operator 类型名() 
{实现转换语句}

3. 注意

1. 函数名前不能指定函数类型，函数没有参数
2. 函数名是operator double，这点和运算符重载时的规律一致
3. 返回值类型，由函数名中指定的类型名来确定（测试不return也行，但只要返回类型必须和指定类型名一致，不然编译报错）
4. 只能作为成员函数，因为转换的主体是本类的对象
5. 形式和重载运算符类似，只是被重载的是类型名。如重载的是double，double除了原来的含义，获得新含义，将一个类对象转换为double数据，并制定了转换方法

④

cmp函数（找最大值）

 

 ⑤

class Vector

{

private:

       T *data;                                    //指向动态数组指针

       int size;                                     //数组的数据元素个数

       int max;                                    //数组容量

       void Error(const char* cs)const{cout<

public:

       enum{SPARE_MAX=16};                           //枚举常量表示数组最小长度

        Vector(int n=SPARE_MAX):: n(max)   ①//转换构造函数,参数初始化列表

              {if(max>0) data=new T[max];size=0;}

// Vector(int n=SPARE_MAX):: max(n)  //你自己是max,n是你引进来的参数

⑥

 cout<④ //迭代器的使用

//  ->sal 迭代器，需要使用箭头运算符来访问迭代器指向的对象的成员。

补充：

迭代器的使用 

遍历容器（vector）元素

for(it=vector.begin();it!=vector.end();it++)
{
  cout<<*it<

vector容器的迭代器定义 

std::vector ::iterator it;     //it能读写vector的元素
std::vector::const_iterator it;//it只能读vector的元素，不可以修改vector中的元素

下面是以vector容器为例的C++代码，仅供参考

#include
#include
#include
using namespace std;
int main()
{
	//要使用的vector容器应该位于所有定义容器语句的最后一句，应在1而不是2 
	vector c;      //1
	vector vector;
	                    //2
	vector.push_back(1);//插入尾部 
	vector.push_back(9);
	vector.push_back(5); 
	
	sort(vector.begin(),vector.end());
	for( int i=0; i::const_iterator it;
	for( it = vector.begin(); it != vector.end(); it++ )
		cout<<"用迭代器输出："<<*it<

 

填空题 

①

       ①  //分数的加法

   fraction &operator+(const fraction&f)

{

       top=top*f.bottom+bottom*f.top;

              bottom=bottom*f.bottom;

              int a=gcd(top,bottom);     

              top=top/a;

              bottom=bottom/a;

              return *this;

    }

1.第一个&：返回值是*this;

2.const的作用是传进一个参数只读不能改写；

3.第二个&：免在函数中复制对象，从而提高程序的效率。

4.参数列表 传进来了一个f,与现在的数做加法运算

②

typedef int Type;

    int operator[](const int id)①     //取下标运算符重载函数const

const Type& operator[](int id)const

{

                if(id<0||id>size-1)

                        Error("id is illegal!\n");

                return data[id];

}

在这个函数中，第一个const关键字表示该函数不会修改对象的成员变量，也就是说，该函数是一个常量成员函数，只能读取对象的成员变量，不能修改它们。

第二个const关键字表示该函数返回的是一个常量引用，也就是说，返回的引用不能被修改，只能被读取。

为什么要返回引用呢？因为返回引用可以避免在函数中复制对象，提高程序的效率。同时，返回引用还可以让函数的返回值可以被当做左值使用，也就是说，可以通过返回值修改对象的成员变量。如果不返回引用，而是返回对象本身，那么修改对象的成员变量就需要使用对象的成员函数，而不能直接通过返回值修改，这样就会增加代码的复杂度。

易错点：题目应该把int 定义成Type ,你写也只能写Type

③

void SeqList::Erase(Type *itr)

{

        for(Type *p=itr,*q=itr+1;q!=data+size;++p,++q)

                *p=*q;    //从p开始，所以元素往前移一格。

        ④       size--                   //修改数据成员

}

你删除了一个元素，就要把容器缩小一个； 

编程题

①

#include
using namespace std;

class Course
{
private:
    int ID;
    int credit;
public:
    int get_credit()const
    {
        return credit;
    }
    Course(int id, int cre) :ID(id), credit(cre) {}

//默认参数构造函数是本题的关键

//有类就有构造函数!

    virtual double totalS() = 0;
    virtual double GPA() = 0;

};
class AdvanceMathematic :public Course
{
    int exam;
    int dailywork;
    double ratio;
public:
    double totalS()
    {
        return exam * 0.6 + dailywork * 0.4;
    }
    double GPA()
    {
        return totalS() / 10.0 - 5;
    }
    AdvanceMathematic(int ex, int dw, int id, int cre):exam(ex), dailywork(dw), Course(id, cre) { }

};
class English :public Course
{
    int exam;
    int dailywork;

public:
    double totalS()
    {
        return exam * 0.7 + dailywork * 0.3;
    }
    double GPA()
    {
        return totalS()/ 10.0 - 5;
    }
    English(int ex, int dw, int id, int cre) :exam(ex), dailywork(dw), Course(id, cre) { }
};
class Cprogram:public Course
{
    int exam;
    int dailywork;

public:
    double totalS()
    {
        return exam * 0.5 + dailywork * 0.5;
    }
    double GPA()
    {
        return (totalS() / 10.0 - 5.0);
    }
    Cprogram(int ex, int dw, int id, int cre) :exam(ex), dailywork(dw), Course(id, cre) { }
};
int main()
{
    Course* p[3];//指针基类
    p[0] = new AdvanceMathematic(80, 90,1001, 4);
    p[1] = new English(80, 60,1002, 3);
    p[2] = new Cprogram(100, 90, 1003, 3);
    int sum = 0;
    double gross = 0;
    
    for (int i = 0;i < 3;i++)
    {
        cout << p[i]->totalS() << endl;
         sum += p[i]->get_credit();
        double gross =  gross+p[i]->get_credit() * p[i]->GPA();//重复定义，gross一直为0

//在循环里面再定义了一个新的gross，和循环外面的不是一个gross，循环结束了里面的gross就删掉了
    }
     cout<      cout<     cout<<"绩点为："<     
    for (int i = 0;i < 3;i++)
    {
        delete p[i];//在堆区开辟，记得释放哟（new)!
    }
    return 0;
}
 

②

 

int main()

{

        String as("To work hard, live a good life. ");

        String cs;

        for(int i=0;i<3;i++)

        {      

                cs=as+cs;

                cout<

        }

    char count='o';

    cout<

        return 0;

}

int String::Count(char ch) //成员函数 加上 String来源

{

        int num=0,i=0;

        int star=0;

       

        while(Find_First_Of(ch,star)||star==0)

                {

                        num++;

                        star=(Find_First_Of(ch,star)+1);

                }

        return num;

}

 ③

 #include"list.h"

template

//出队则为队列

class Queue

{

         List queueL;

public:

         Queue(){}

         ~Queue(){}

    int Size()const                                       //求长

                   {return queueL.Size();}   

         int Empty()const                                  //判空

                   {return queueL.Empty();}        

         const T& Front()const                         //取队头元素

                   {return queueL.Front();} 

        void Push(const T& item)                  //入队

                   {if(item<=80)

                            queueL.Push_back(item);

                   else

                            queueL.Push_front(item);        }

    T Pop()                                                             //出队

                   { T item=queueL.Front(); queueL.Pop_front(); return item;}

//先获得最前面的元素，记录它，然后把最前面的挤出去，返回第一个数的值

    void Clear()                                            //置空队

                   {queueL.Clear();}     

};

int main()

{

         Queue q;

         q.Push(18);

         q.Push(22);

         q.Push(88);

         int num=q.Size();

         for(int i=0;i

                   cout<

}