写在前面：
只有题目内容和代码，没有解释。
2013年：（仅供参考）
请按要求编写一个类Circle，用于描述一个圆形，并用给定的main函数测试Circle类的功能。Circle类的要求如下：
1.包含圆形编号、圆心x坐标、圆心y坐标和半径等数据成员。圆形编号为整形。生成第1个圆形对象时编号为1，生成第2个圆形对象时编号为2，以此类推。每构造一个新的圆形，对象编号为当前最大编号加1（如当前最大编号为5，则生成的这个新圆形的编号应该为6）。
2.是否需要其它数据成员，可视情况自行决定。提示：建议使用两个静态变量。一个静态变量用于记录当前圆形对象的个数，此变量的值可增大或减小；另一个静态变量用于记录已经生成的圆形对象的最大编号，此变量的值只会增大不会减小。
3.1个带有3个参数的构造函数。3个参数分别初始化圆形的圆心x坐标、圆心y坐标和半径等数据成员。提示：圆形对象的编号也需要初始化。
4.1个拷贝构造函数。提示：圆形对象的编号不能简单复制。
5.1个获取当前圆形对象数量的函数。提示：此函数建议为静态函数。
6.前自增运算符，对半径自增1。
7.后自增运算符，对半径自增1。
8.+运算符，用于将两个圆形加在一起，得到一个新的圆形。新圆形的圆心坐标是两个圆形坐标连线的中点，面积是两个圆形面积的和。提示：需要根据面积反算半径。
9.流输出运算，用于显示圆形的编号、圆心x坐标、圆心y坐标和半径、面积、周长。一个圆形的信息占1行。
10.析构函数。圆形对象销毁时，需要将当前圆形对象的数量减去1。
11.使用给定的main函数测试Circle类的功能。

题目给的main测试函数里面没有析构函数的测试，菜狗如我就只减了一下

//author CN.TTDragon
#include<bits/stdc++.h>
typedef long long ll;
const ll mod=1e9+7;
const ll maxn=1e5+7;
const double pi=acos(-1);
using namespace std;
class Circle
{
    private:
        int id;
        static int num,mx;//静态数据成员
        double x,y,r;
    public:
        Circle(double a,double b,double c)
        {
            x=a;
            y=b;
            r=c;
            id=num+1;
            num++;
            if(num>mx)
            {
                mx++;
            }
        }
        Circle(const Circle &yuan)
        {
            x=yuan.x;
            y=yuan.y;
            r=yuan.r;
            num=yuan.num+1;
            id=num;
            if(num>mx)
            {
                mx++;
            }
        }
        ~Circle()
        {
            num--;
        }
        static get_num()
        {
            return num;
        }
        friend ostream& operator<<(ostream& o, const Circle& yuan1);//流输出写成友元函数
        friend ostream& operator+(const Circle& yuan1);
        double getx() const
        {
            return x;
        }
        double gety() const 
        {
            return y;
        }
        double getr() const
        {
            return r;
        }
        friend Circle & operator++(Circle& yuan1)
        {
            yuan1.r=yuan1.r+1; 
            return yuan1;
        }
        friend Circle  operator++(Circle& yuan,int b)
        {
            Circle yuan2(yuan);

              yuan.r=yuan.r+1;

              return yuan2;
        }

}; 

int Circle::num =0;
int Circle::mx =0;

ostream& operator<<(ostream& o, const Circle& yuan1)
{
    o<<yuan1.id<<" "<<yuan1.x<<" "<<yuan1.y<<" "<<yuan1.r<<" "<<2*pi*yuan1.r<<" "<<pi*yuan1.r*yuan1.r<<endl;
}

Circle operator+(const Circle& yuan1,const Circle& yuan2)//写的稀烂
{
    double sss=pi*yuan1.getr()*yuan1.getr()+pi*yuan2.getr()*yuan2.getr();
    double rrr=sqrt(sss/pi);

    Circle new1((yuan2.getx()+yuan1.getx())/2,(yuan1.gety()+yuan2.gety())/2,rrr);
    return new1;
}

int main()
{
    Circle c1( 1.12, 2.23, 3.34 ), c2( c1 );

    cout << c1 << c2;
    cout << "Number of circles = " << Circle::get_num() << endl;

    Circle c3 = c1 + c2;
    cout << c3;
    cout << "Number of circles = " << Circle::get_num() << endl;

    cout << c1++;
    cout << ++c2;
    cout << c1;

    return 0;
}

2014年：
请按要求编写一个类Timer，用于描述一个计时器，并用给定的main函数测试Timer类的功能。Timer类的要求如下：

  1. 该类数据成员包含分钟minute，秒second。均为整型。分钟和秒取值范围为0-59。注意：两个数据成员均为私有。
  2. 1个带有2个参数的构造函数，缺省值都为0。2个参数分别初始化计时器对象的分钟和秒值。注意：初始化值超过分钟和秒取值范围的自动设为0。
  3. 1个拷贝构造函数。
  4. 用常成员函数实现get_minute()/get_second()，返回minute和second值。
  5. 前自增运算符++重载。注意：先增加秒second值，如果超过59，秒值清零，分钟加1；如果分钟值超过59，分钟值清零。
  6. 后自增运算符++重载。注意事项同上。
  7. 重载减法运算符-，实现两个Timer相减，得到它们的时间差，时间差也是一个Timer对象；注意：先判断哪个Timer大，用大的减去小的，减法中利用1分钟=60秒。
  8. 写一个友元函数write(Timer &c, ofstream &os)，将一个计时器对象写入到一个文件中，包括计时器的分钟和秒值，中间用“：”隔开。一个计时器的信息占1行。
  9. 流输出运算，用于显示计时器的分钟和秒值，中间用“：”隔开。一个计时器的信息占1行。
  10. 使用给定的main函数测试Timer类的功能。 
//author CN.TTDragon
#include<bits/stdc++.h>
typedef long long ll;
const ll mod=1e9+7;
const ll maxn=1e5+7;
const double pi=acos(-1);
using namespace std;
class timer
{
    private:
        int m,s;
    public:
        timer(const timer &t);
        timer(int mm=0,int ss=0)
        {
            m=mm;
            s=ss;    
        }
        int get_minute()
        {
            return m;
        }
        int get_second()
        {
            return s;
        }
        timer & operator++()
        {
            s++;
            if(s==60)
            {
                m++;
                s=0;
            }
            if(m==60)
            {
                m=0;
            }
            return (*this);
        }
        timer & operator++(int b)
        {
            timer temp(*this);
            s++;
            if(s==60)
            {
                m++;
                s=0;
            }
            if(m==60)
            {
                m=0;
            }
            return temp;
        }
        timer & operator-(const timer & t)
        {
            int tot=m*60+s-t.m*60-t.s; 
            tot=abs(tot);
            tot=tot%3600;
            timer now1(tot/60,tot%60);
            return now1;
        }

        friend ostream& operator<<(ostream& o, const timer& tt)
        {
            o<<tt.m<<" : "<<tt.s<<endl;

        }    
        friend void write(const timer &t, ofstream &os);
};
timer::timer(const timer &t)
{
    this->m=t.m;
    this->s=t.s;
}
void write(const timer & t,ofstream & os)
{

    //os << t.get_minute() << ":" << t.get_second() << endl;
    os << t.m << ":" << t.s << endl;

}
int main()
{
    ofstream os("timer.txt");
    timer t1, t2(20, 59), t3( t2 );

    cout << t1 << t2 << t3;

    timer* t4 = new timer(2,49);
    cout << t4->get_minute() <<" " << t4->get_second() << endl;
    delete t4;

    ++t1;
    cout << t1;
    t3++;
    cout << t3;

    timer t5 = t3 - t1;
    cout << t5;

    write(t1, os);
    write(t2, os);
    write(t3, os);
    write(t5, os);

    os.close();
    return 0;
}

以下是timer.txt

0:1
20:59
21:0
20:59

写在最后：
2020第二次测试加油。