C++_第五周做题总结_构造与析构

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量910 收藏 20
点赞数 17
分类专栏： C++做题总结 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79837864/article/details/137744997
版权

id:31 A.Point（类与构造）

题目描述

下面是一个平面上的点的类定义，请在类外实现它的所有方法，并生成点测试它。

class Point
{
    double x, y;
public:
    Point(); // 缺省构造函数，给x,y分别赋值为0
    Point(double x_value, double y_value); // 有参构造函数
    double getX(); // 返回x的值
    double getY();
    void setX(double x_value); // 设置x的值
    void setY(double y_value);
    double dis(Point p); // 计算当前点到参数点的距离
};

输入

测试数据的组数 t

第一组测试数据点p1的x坐标 第一组测试数据点p1的y坐标 第一组测试数据点p2的x坐标 第一组测试数据点p2的y坐标

…

输出

输出p1到p2的距离，保留两位小数。详情参考输出样例。

在C++中，输出指定精度的参考代码如下：

#include <iostream>

#include <iomanip> //必须包含这个头文件

using namespace std;

void main( )

{ double a =3.14;

  cout<<fixed<<setprecision(3)<<a<<endl;  //输出小数点后3位

}

输入样例

2
1 2 3 4
-1 0.5 -2 5

输出样例

Distance of Point(1.00,2.00) to Point(3.00,4.00) is 2.83
Distance of Point(-1.00,0.50) to Point(-2.00,5.00) is 4.61

题解

  • 首先分析class类，Point(); // 缺省构造函数，给x,y分别赋值为0，这行代码的意思是，当使用Point类型定义一个变量且后面不跟任何参数时，会默认的执行这个函数，即为x, y分别赋值为0；Point(double x_value, double y_value); // 有参构造函数，若用Point类型定义一个变量，且这个变量后面带参数，即会给这个变量的成员x和y赋括号里参数的值；double getX(); // 返回x的值，当调用这个函数时，我们的目的是得到Point类型的变量的成员x的值；同理double getY();这个代码的功能也是一样的；void setX(double x_value); // 设置x的值，当调用这个函数时，会将调用这个函数的变量的x的值改变为参数的值；同理void setY(double y_value);；double dis(Point p); // 计算当前点到参数点的距离，在这个函数中，我们还要额外定义三个变量，一个用来存储两个点之间横坐标距离之差，一个用来存储纵坐标距离之差，还有一个用来存储计算得到的距离并返回，注意，在计算两个点之间的距离时，我们需要使用到两个点的横纵坐标的值，故会引起怎么引用的问题，我们需要用一个参数来调用这个计算两个点之间的距离的函数，故完成了一个点的调用，然后这个函数是带有参数的，把另一个点当作参数调用，则完成了两个点的调用，在这个函数中，x和y是调用这个函数的变量的成员，而怎么调用另一个变量的横纵坐标呢，则需要使用get函数，这个另一个点调用这个函数，然后会返回这个变量的横纵坐标，则实现了两个点的横纵坐标的调用
  • 然后来看主函数的功能，在主函数中，我们需要定义测试组数和遍历变量，一个用于接收返回距离两点间答案的变量，然后定义一个Point类型的变量，这个变量会执行一次缺省构造函数，还要定义四个变量用于接收输入进来的两个点的横纵坐标的值
  • 一个for循环，遍历完全组的两点，输入两个点的横纵坐标，然后定义一个Point类型的变量，带两个参数，将这两个参数的值赋到这个变量的横纵坐标变量，再调用类里边的set函数，将另外两个横纵坐标赋值到这个调用的变量的横纵坐标变量上，为什么要怎么麻烦，我也不懂，因为题目要求用上所有的类里边的函数，只能这样
  • 最后就是按着输出样例的格式输出距离

代码实现

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

class Point
{
    double x, y;
public:
    Point(); // 缺省构造函数，给x,y分别赋值为0
    Point(double x_value, double y_value); // 有参构造函数
    double getX(); // 返回x的值
    double getY();
    void setX(double x_value); // 设置x的值
    void setY(double y_value);
    double dis(Point p); // 计算当前点到参数点的距离
};

Point::Point()
{
    x = 0;
    y = 0;
}

Point::Point(double x_value, double y_value)
{
    x = x_value;
    y = y_value;
}

double Point::getX()
{
    return x;
}

double Point::getY()
{
    return y;
}

void Point::setX(double x_value)
{
    x = x_value;
}

void Point::setY(double y_value)
{
    y = y_value;
}

double Point::dis(Point p)
{
    double result, dx, dy;
    dx = x - p.getX();
    dy = y - p.getY();
    result = sqrt(dx * dx + dy * dy);
    return result;
}

int main()
{
    int t, i;
    double ans, p1x, p1y, p2x, p2y;
    Point p2;
    cin >> t;

    for (i = 0; i < t; i++)
    {
        cin >> p1x >> p1y >> p2x >> p2y;
        Point p1(p1x, p1y);
        p2.setX(p2x);
        p2.setY(p2y);
        ans = p1.dis(p2);

        cout << "Distance of Point(" << fixed << setprecision(2) << p1.getX() << "," << fixed << setprecision(2) << p1.getY() << ") to Point(" << fixed << setprecision(2) << p2.getX() << "," << fixed << setprecision(2)<< p2.getY() << ") is ";
        cout << fixed << setprecision(2) << ans << endl;
    }

    return 0;
}

id:32 B.Date（类与构造）

题目描述

下面是一个日期类的定义，请在类外实现其所有的方法，并在主函数中生成对象测试之。

class Date
{
    int year, month, day;
public:
    Date(); // 缺省构造函数
    Date(int y, int m, int d); // 带参构造函数
    int getYear(); // 返回当前日期的年份
    int getMonth();
    int getDay();
    void setDate(int y, int m, int d); // 按参数重设日期的值
    void print(); // 按格式输出当前日期的年、月、日
    void addOneDay(); // 在当前日期上加一天
};

注意，在判断明天日期时，要加入跨月、跨年、闰年的判断

例如9.月30日的明天是10月1日，12月31日的明天是第二年的1月1日

2月28日的明天要区分是否闰年，闰年则是2月29日，非闰年则是3月1日

输入

测试数据的组数t

第一组测试数据的年 月 日

…

要求第一个日期的年月日初始化采用构造函数，第二个日期的年月日初始化采用setDate方法，第三个日期又采用构造函数，第四个日期又采用setDate方法，以此类推。

输出

输出今天的日期

输出明天的日期

输入样例1

4
2012 1 3
2012 2 28
2012 3 31
2012 4 30

输出样例1

Today is 2012/01/03
Tomorrow is 2012/01/04
Today is 2012/02/28
Tomorrow is 2012/02/29
Today is 2012/03/31
Tomorrow is 2012/04/01
Today is 2012/04/30
Tomorrow is 2012/05/01

输入样例2

4
2014 1 3
2014 2 28
2014 3 31
2014 4 30

输入样例3

3
2000 2 29
2014 3 31
2014 12 31

提示

C++中设置填充字符的代码参考如下：

cout << setfill('0') << setw(2) << month; //设置宽度为2，前面补'0'

需要头文件#include <iomanip>

题解

  • 首先来分析日期类，Date(); // 缺省构造函数，用来初始化类里面的年月日；Date(int y, int m, int d); // 带参构造函数，用来给年月日赋参数的值，int getYear(); // 返回当前日期的年份，通过调用这个函数，我们可以得到调用这个函数的变量的年份的值；同理int getMonth(); int getDay();这两行的代码功能相同；void setDate(int y, int m, int d); // 按参数重设日期的值将日期的值设为参数的值，这个函数可以用在初始化一个Date类型的变量中；void print(); // 按格式输出当前日期的年、月、日，这个函数只用于输出当天日期的值，即，当输入一个日期时，便马上调用这个函数输出这个日期的值；void addOneDay(); // 在当前日期上加一天，这个函数用来计算输入的日期的下一天的日期
  • void addOneDay(); // 在当前日期上加一天，在这个函数中，我们先用日作为if语句判断的条件，然后再判断月份，最后判断年份；具体来数，我们把判断的条件划分为，是否是28号，29号，30号和31号这几个特殊的日期，如果是28号的话，再判断其是否是2月份，再判断其是否是闰年，如果是29号的话，判断其是否是二月份，但是不用再判断是否是闰年，如果是30号的话，要分大小月；31号特殊的地方在于要判断他的月份是否是12月，如果是的话要年份加一
  • 然后来看看主函数的功能，需要定义用于存储输入进来的年月日的变量，然后还要定义Date类型的变量，因为需要年月日的成员，在定义这个变量是，程序自动地执行缺省构造函数
  • 然后进行输入，因为题目有要求，所以需要根据不同的输入次数采用不同的方法初始化变量，当输入的次数为奇数次时，采用带参构造函数法，因为此时已经输入了年月日，要把输入进来的年月日传入变量中，随即调用输出函数输出当前的日期，然后调用日期加一函数，计算加一后的日期，然后在主函数中输出加了一天后的日期；如果输入次数为偶数次时，日期的初始化采用setDate方法,即调用这个函数初始化变量，后面的步骤相同

代码实现

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

class Date
{
    int year, month, day;
public:
    Date(); // 缺省构造函数
    Date(int y, int m, int d); // 带参构造函数
    int getYear(); // 返回当前日期的年份
    int getMonth();
    int getDay();
    void setDate(int y, int m, int d); // 按参数重设日期的值
    void print(); // 按格式输出当前日期的年、月、日
    void addOneDay(); // 在当前日期上加一天
};

Date::Date()
{
    year = 1900;
    month = 1;
    day = 1;
}

Date::Date(int y, int m, int d)
{
    year = y;
    month = m;
    day = d;
}

int Date::getYear()
{
    return year;
}

int Date::getMonth()
{
    return month;
}

int Date::getDay()
{
    return day;
}

void Date::setDate(int y, int m, int d)
{
    year = y;
    month = m;
    day = d;
}

void Date::print()
{
    cout << "Today is " << setfill('0') << setw(2) << year << "/" << setfill('0') << setw(2) << month << "/" << setfill('0') << setw(2) << day << endl;
}

void Date::addOneDay()
{
    if (day == 28)
    {
        if (month == 2)
        {
            if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) // 是闰年
            {
                day++;
            }
            else // 不是闰年
            {
                day = 1;
                month++;
            }
        }
    }
    else if (day == 29)
    {
        if (month == 2)
        {
            day = 1;
            month++;
        }
        else
        {
            day++;
        }
    }
    else if (day == 30)
    {
        switch (month)
        {
            case 1: day++;
                    break;
            case 3: day++;
                    break;
            case 4: day = 1;
                    month++;
                    break;
            case 5: day++;
                    break;
            case 6: day = 1;
                    month++;
                    break;
            case 7: day++;
                    break;
            case 8: day++;
                    break;
            case 9: day = 1;
                    month++;
                    break;
            case 10: day++;
                    break;
            case 11: day = 1;
                     month++;
                     break;
            case 12: day++;
                    break;
            }
        }
    else if (day == 31)
    {
        if (month == 12)
        {
            day = 1;
            year++;
            month = 1;
        }
        else
        {
            day = 1;
            month++;
        }
    }
    else
    {
        day++;
    }
}

int main()
{
    int t, i, yy, mm, dd;;
    Date DD;
    cin >> t;

    for (i = 0; i < t; i++)
    {
        cin >> yy >> mm >> dd;
        if (i % 2 == 0)
        {
            Date DD0(yy, mm, dd);
            DD0.print();
            DD0.addOneDay();
            cout << "Tomorrow is " << setfill('0') << setw(2) << DD0.getYear() << "/" << setfill('0') << setw(2) << DD0.getMonth() << "/" << setfill('0') << setw(2) << DD0.getDay() << endl;
        }
        else
        {
            DD.setDate(yy, mm, dd);
            DD.print();
            DD.addOneDay();
            cout << "Tomorrow is " << setfill('0') << setw(2) << DD.getYear() << "/" << setfill('0') << setw(2) << DD.getMonth() << "/" << setfill('0') << setw(2) << DD.getDay() << endl;
        }
    }

    return 0;
}

id:33 C.分数类（类与构造）

题目描述

完成下列分数类的实现:

class CFraction
{
private:
     int fz, fm;
public:
     CFraction(int fz_val, int fm_val) ;
     CFraction add(const CFraction &r);
     CFraction sub(const CFraction &r);
     CFraction mul(const CFraction &r);
     CFraction div(const CFraction &r);
     int getGCD();   // 求对象的分子和分母的最大公约数
     void print();
};

求两数a、b的最大公约数可采用辗转相除法，又称欧几里得算法，其步骤为:

  1. 交换a, b使a > b;
  2. 用a除b得到余数r,若r=0,则b为最大公约数,退出.
  3. 若r不为0,则用b代替a, r代替b,此时a,b都比上一次的小,问题规模缩小了;
  4. 继续第2步。

注意：如果分母是1的话，也按“分子/1”的方式输出。

输入

测试数据的组数 t

第一组第一个分数

第一组第二个分数

第二组第一个分数

第二组第二个分数

…

输出

第一组两个分数的和

第一组两个分数的差

第一组两个分数的积

第一组两个分数的商

第二组两个分数的和

第二组两个分数的差

第二组两个分数的积

第二组两个分数的商

…

输入样例

3
1/2
2/3
3/4
5/8
21/23
8/13

输出样例

7/6
-1/6
1/3
3/4

11/8
1/8
15/32
6/5

457/299
89/299
168/299
273/184

题解

  • 首先来看CFraction类，CFraction(); // 缺省构造函数，将fz和fm都赋值为1；CFraction(int fz_val, int fm_val); // 带参构造函数，将fz和fm都赋值为参数的值；CFraction add(const CFraction& r);，在这个函数中，要定义整形三个变量，一个用来将分子相加得到的结果存储，一个将新得到的分母进行存储，还要定义一个CFraction类型的变量，定义时要含参，参数即是新的分子分母，这个变量的分子和分母即是得到的新的分子和分母，然后这个新定义的变量调用求最大公约数的函数，将得到的最大公约数的值存储到一个整型变量中，然后更新分子和分母，即是分子和分母约分后的值，再定义一个CFraction类型的变量，也要含参，参数就是更新后的分子分母，作用就是，将参数赋值给这个变量的分子分母，故这个变量就是两个分数相加的结果，返回最后定义的这个CFraction类型的变量；后面的和差积商都是相同的方法；int getGCD(); // 求对象的分子和分母的最大公约数，用到的方法是辗转相除法，需要注意的是，如果出现了负数，我们需要确保这个计算得到的最大公约数的结果，及返回值是正数，所以我们需要判断参数进来的是否是正数；void print();，进行简单的输出即可
  • 在主函数中，我们需要定义四个整型变量，用来存储输入进来的两个分数的分子和分母，还要定义一个char型的变量，用来存储"/"，输入两个分数的分子和分母后，定义两个CFraction类型的变量，后面带两个参数，即是要赋值到这个变量的分子和分母的参数，还要定义一个CFraction类型的变量，这个变量用来存储计算后返回的结果，然后这个变量调用输出函数进行计算后得到的结果进行输出，每做完一个计算就调用一次输出函数进行输出

反思

在类函数的实现时，如两个分数的相加，一开始我没有额外的定义一个整形变量来存储计算后的分子分母的值，而是将计算后的值直接更新到调用这个加法函数的变量的分子上，导致后来这个分数的分子已经不是原来输入的分子，即他的值已经改变，所以后面再进行的减法，乘法和除法得到的结果都是错的

代码实现

#include <iostream>
using namespace std;

class CFraction
{
private:
    int fz, fm;
public:
    CFraction(); // 缺省构造函数
    CFraction(int fz_val, int fm_val); // 带参构造函数
    CFraction add(const CFraction& r);
    CFraction sub(const CFraction& r);
    CFraction mul(const CFraction& r);
    CFraction div(const CFraction& r);
    int getGCD(); // 求对象的分子和分母的最大公约数
    void print();
};

CFraction::CFraction()
{
    fz = 1;
    fm = 1;
}

CFraction::CFraction(int fz_val, int fm_val)
{
    fz = fz_val;
    fm = fm_val;
}

CFraction CFraction::add(const CFraction& r)
{
    int new_fz, new_fm, gcd;
    new_fz = fz * r.fm + r.fz * fm;
    new_fm = fm * r.fm;
    CFraction f(new_fz, new_fm);
    gcd = f.getGCD();
    new_fz /= gcd;
    new_fm /= gcd;
    CFraction ff(new_fz, new_fm);
    return ff;
}

CFraction CFraction::sub(const CFraction& r)
{
    int new_fz, new_fm, gcd;
    new_fz = fz * r.fm - r.fz * fm;
    new_fm = fm * r.fm;
    CFraction f(new_fz, new_fm);
    gcd = f.getGCD();
    new_fz /= gcd;
    new_fm /= gcd;
    CFraction ff(new_fz, new_fm);
    return ff;
}

CFraction CFraction::mul(const CFraction& r)
{
    int new_fz, new_fm, gcd;
    new_fz = fz * r.fz;
    new_fm = fm * r.fm;
    CFraction f(new_fz, new_fm);
    gcd = f.getGCD();
    new_fz /= gcd;
    new_fm /= gcd;
    CFraction ff(new_fz, new_fm);
    return ff;
}

CFraction CFraction::div(const CFraction& r)
{
    int new_fz, new_fm, gcd;
    new_fz = fz * r.fm;
    new_fm = fm * r.fz;
    CFraction f(new_fz, new_fm);
    gcd = f.getGCD();
    new_fz /= gcd;
    new_fm /= gcd;
    CFraction ff(new_fz, new_fm);
    return ff;
}

int CFraction::getGCD()
{
    int a, b, r, x;
    a = fm;
    b = fz;
    if (b < 0)
    {
        b = -b;
    }
    if (a < b) // 确保a > b
    {
        x = a;
        a = b;
        b = x;
    }
    r = a % b;
    while (r != 0)
    {
        a = b;
        b = r;
        r = a % b; // r为余数
    }
    return b;
}

void CFraction::print()
{
    cout << fz << "/" << fm << endl;
}

int main()
{
    int t, i, x1, x2, y1, y2;
    char ch;
    cin >> t;
    
    for (i = 0; i < t; i++)
    {
        cin >> x1 >> ch >> x2 >> y1 >> ch >> y2;
        CFraction x(x1, x2);
        CFraction y(y1, y2);
        CFraction result;

        result = x.add(y);
        result.print();

        result = x.sub(y);
        result.print();

        result = x.mul(y);
        result.print();

        result = x.div(y);
        result.print();
        cout << endl;
    }

    return 0;
}

id:34 D.Point_Array（类+构造+对象数组）

题目描述

在这里插入图片描述
上面是我们曾经练习过的一个习题，请在原来代码的基础上作以下修改：

1、增加自写的析构函数；

2、将getDisTo方法的参数修改为getDisTo(const Point &p)；

3、根据输出的内容修改相应的构造函数。

然后在主函数中根据用户输入的数目建立Point数组，求出数组内距离最大的两个点之间的距离值。

输入

测试数据的组数 t

第一组点的个数

第一个点的 x 坐标 y坐标

第二个点的 x坐标 y坐标

…

输出

输出每组中距离最大的两个点以及其距离（存在多个距离都是最大值的情况下，输出下标排序最前的点组合。比如如果p[0]和p[9]、p[4]和p[5]之间的距离都是最大值，那么前一个是答案，因为p[0]排序最前）

…

在C++中，输出指定精度的参考代码如下：

#include

#include //必须包含这个头文件

using namespace std;

void main( )

{ double a =3.141596;

cout<<fixed<<setprecision(3)<<a<<endl; //输出小数点后3位

输入样例

2
4
0 0
5 0
5 5
2 10
3
-1 -8
0 9
5 0

输出样例

Constructor.
Constructor.
Constructor.
Constructor.
The longest distance is 10.44,between p[1] and p[3].
Distructor.
Distructor.
Distructor.
Distructor.
Constructor.
Constructor.
Constructor.
The longest distance is 17.03,between p[0] and p[1].
Distructor.
Distructor.
Distructor.

题解

  • 首先分析类，Point(); // 缺省构造函数，输出，因为看到输出样例中，每输入一个点的横纵坐标都伴随着一个Constructor.的输出，故可以知道，这个缺省构造函数的作用是输出Constructor.；Point(double x_value, double y_value); // 有参构造函数，给x,y赋参数的值，这个构造函数的作用是把调用这个变量的横纵坐标的值改变为参数的值；~Point(); // 析构函数，输出，同理，观察到每输入一个横纵坐标的值，都会伴随着Distructor.的输出，且这个输出在输出了距离之后才输出；double getX(); // 返回x的值，作用是当在调用这个函数时，返回横坐标的值，即是当我们需要这个变量的横坐标时，我们就可以调用这个函数；double getY();，同理；void setXY(double x1, double y1); // 赋参数的值，当调用这个函数时，这个函数就会改变横纵坐标的值为参数的值；void setX(double x_value); // 设置x的值，当在调用这个函数时，这个变量的横坐标就会变为参数的值；void setY(double y_value);，同理；double getDisTo(const Point& p); // 计算当前点到参数p的距离，在这个函数中，我们首先要定义三个变量，一个用来存储两个点横坐标之差，横坐标之差的计算是，直接用调用这个函数的横坐标的值减去参数的横坐标的值，怎么得到参数的横坐标的值呢，因为参数也是一个Point类型的变量，所以我们可以使用”."来访问它的成员，即是它的横坐标的值，另一个变量用来存储纵坐标之差，还有一个变量用来存储计算得到的两点之间的距离，并返回
  • 然后来看主函数的作用，因为我们要比较两个点的距离，而我们又会输入多个不同的点，所以我们会考虑用一个Point类型的数组来存储这些点的信息，题目有要求用动态创建的方法，所以我们采用new的方法，注意，使用后要释放内存，我们还要创建变量来存储输入进来的横纵坐标的值，这些值输入进来后我们要将他们赋值到到点的横纵坐标中，所以这时我们调用void setXY(double x1, double y1)函数
  • 然后我们编写计算两个点之间的距离的代码，我们可以使用两个嵌套的for循环，达到逐个遍历两个点，然后调用距离计算函数返回这两个点的距离，在用这个返回值与当前最大值进行比较，再进行更新和记录此时的横纵坐标的值的操作
  • 最后就是进行一些简单的输出

疑问

  • 为什么这段代码
double Point::getDisTo(const Point& p)
{
    double result, dx, dy;
    dx = x - p.x;
    dy = y - p.y;
    result = sqrt(dx * dx + dy * dy);
    return result;
}

不能写成

double Point::getDisTo(const Point& p)
{
    double result, dx, dy;
    dx = x - p.getX();
    dy = y - p.getY();
    result = sqrt(dx * dx + dy * dy);
    return result;
}

代码实现

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

class Point
{
    double x, y;
public:
    Point(); // 缺省构造函数，输出
    Point(double x_value, double y_value); // 有参构造函数，给x,y赋参数的值
    ~Point(); // 析构函数，输出
    double getX(); // 返回x的值
    double getY();
    void setXY(double x1, double y1); // 赋参数的值
    void setX(double x_value); // 设置x的值
    void setY(double y_value);
    double getDisTo(const Point& p); // 计算当前点到参数p的距离
};

Point::Point()
{
    cout << "Constructor." << endl;
}

Point::Point(double x_value, double y_value)
{
    x = x_value;
    y = y_value;
}

Point::~Point()
{
    cout << "Distructor." << endl;
}

double Point::getX()
{
    return x;
}

double Point::getY()
{
    return y;
}

void Point::setXY(double x1, double y1) // 赋参数的值
{
    x = x1;
    y = y1;
}

void Point::setX(double x_value)
{
    x = x_value;
}

void Point::setY(double y_value)
{
    y = y_value;
}

double Point::getDisTo(const Point& p)
{
    double result, dx, dy;
    dx = x - p.x; // 疑问
    dy = y - p.y;
    result = sqrt(dx * dx + dy * dy);
    return result;
}

int main()
{
    int t, i, n, j, k, x, y;
    double x1, y1, max, dis;
    cin >> t; // 组数

    for (i = 0; i < t; i++)
    {
        max = 0;
        dis = 0;
        cin >> n; // 点的个数
        Point* pp = new Point[n]; // 动态创建数组
        for (j = 0; j < n; j++)
        {
            cin >> x1 >> y1; // 横纵坐标的值
            pp[j].setXY(x1, y1); // 赋参数的值
        }

        for (j = 0; j < n; j++) // 计算两个点之间的距离
        {
            for (k = j + 1; k < n; k++)
            {
                dis = pp[j].getDisTo(pp[k]);
                if (max < dis)
                {
                    max = dis; // 更新
                    x = j; // 记录横纵坐标
                    y = k;
                }
            }
        }

        cout << "The longest distance is " << fixed << setprecision(2) << max;
        cout << ",between p[" << x << "]" << " and p[" << y << "]." << endl;
        delete[] pp; // 释放内存
    }

    return 0;
}

id:35 E.Stack（类与构造）

题目描述

class CStack
{
public:
    CStack(); // 建立一个10个元素的栈
    CStack(int s); // 建立一个具有s个元素的栈
    int get(int index); // 返回下标为index的栈元素
    void push(int n); // 进栈，top加1，把n的值存入栈顶
    int isEmpty(); // 判断栈否是空的，空则返回一，否则返回0
    int isFull(); // 判断栈是否是满的，满则返回1，否则返回0
    int pop(); // 出栈，返回栈顶元素，top减1
    ~CStack(); // 析构函数，释放在构造时申请的空间
private:
    int* a;
    int size; // 栈的大小
    int top; // 指向栈顶
};

上面是栈类的定义，栈是一种具有先进后出特点的线性表，请根据注释，完成类中所有方法的实现，并在主函数中测试之。

堆栈类的说明如下：

  1. 堆栈的数据实际上是保存在数组a中，而a开始是一个指针，在初始化时，根据实际需求将a动态创建为数组，数组长度根据构造函数的参数决定。

  2. size实际上就是数组的长度，当使用无参构造则size为10，当使用有参构造则size为s、

  3. top表示数组下标，也表示数组中下一个存放数据的空白位置。

  4. push操作表示堆栈的数组存放一个数据，例如一开始数组为空，则top为0，当有数据要入栈时，把数据存放在a[top]的位置，然后top加1指向下一个空白位置、数据进栈只能从栈顶进。

  5. pop操作表示一个数据要出栈，数据出栈只能从栈顶出，先把top减1指向栈顶数据，然后把数据返回。

  6. 判断堆栈空的条件是top是否等于0，判断堆栈满的条件是top是否等于size

输入

测试数据的组数 t

第一个栈的大小

第一个栈的元素列表，将该列表的元素依次进栈

…

输出

将栈元素依次出栈

输入样例

2
5
1 2 3 4 5
7
-1 2 8 0 -3 1 3

输出样例

Constructor.
5 4 3 2 1
Destructor.
Constructor.
3 1 -3 0 8 2 -1
Destructor.

题解

  • 首先来解释类，即栈的建立，CStack(); // 建立一个10个元素的栈，在这个函数中，我们要实现将栈的大小，及数组的大小设置为10，然后我们还要动态创建一个数组，即a，还要将top，及记录指向数组的一个整形变量，就是数组的下标初始化为0，即指向第一个位置，那为什么我们要在构造函数中动态创建一个数组和初始化一个变量的值呢，因为我们这个数组已经在类中定义好了，而不是在主函数中定义好的，我们主要的操作就是对这个数组进行操作，而在主函数中我们定义一个CStack类型的变量的作用是调用这些对栈进行的操作的函数，所以最先会调用到这个构造函数，所以我们在一开始就要动态创建数组和初始化变量；CStack(int s); // 建立一个具有s个元素的栈，这也是一个构造函数，所以我们在将参数设置为栈的大小时还要动态创建数组和初始化变量，使得无论主函数调用了那个构造函数，数组都得以创建，变量得以初始化；int get(int index); // 返回下标为index的栈元素，调用这个函数时我们会得到一个值，即下表为参数的数组元素的值；void push(int n); // 进栈，top加1，把n的值存入栈顶，在这个函数中，我们把参数赋值给当前数组的空白位置，然后将数组的下标加一，使得可以存放下一次的值；int isEmpty(); // 判断栈否是空的，空则返回一，否则返回0，题目有讲怎么判断；int isFull(); // 判断栈是否是满的，满则返回1，否则返回0，同理；int pop(); // 出栈，返回栈顶元素，top减1，出栈时表示数组下标的值要减一，然后把当前数组的元素返回，要先减一再返回值，因为前面的操作会使这个这个数组下标的变量指向了一个空的地方；~CStack(); // 析构函数，释放在构造时申请的空间，释放空间和输出一句话
  • 在主函数中，我们首先要定义一个CStack类型的变量，目的是把输入进来的栈的大小设置为类中数组的大小，然后把输入进去的值通过调用进栈函数进栈，然后通过判断栈是满的还是空的，还是其他的情况，通过调用出栈函数输出元素的值，主要是使得输出和样例相同

代码实现

#include <iostream>
using namespace std;

class CStack
{
public:
    CStack(); // 建立一个10个元素的栈
    CStack(int s); // 建立一个具有s个元素的栈
    int get(int index); // 返回下标为index的栈元素
    void push(int n); // 进栈，top加1，把n的值存入栈顶
    int isEmpty(); // 判断栈否是空的，空则返回一，否则返回0
    int isFull(); // 判断栈是否是满的，满则返回1，否则返回0
    int pop(); // 出栈，返回栈顶元素，top减1
    ~CStack(); // 析构函数，释放在构造时申请的空间
private:
    int* a;
    int size; // 栈的大小
    int top; // 指向栈顶
};

CStack::CStack()
{
    size = 10;
    a = new int[size]; // 分配内存空间
    top = 0; // 初始化
    cout << "Constructor." << endl;
}

CStack::CStack(int s)
{
    size = s;
    a = new int[size]; // 分配内存空间
    top = 0; // 初始化
    cout << "Constructor." << endl;
}

int CStack::get(int index)
{
    return a[index];
}

void CStack::push(int n)
{
    a[top] = n;
    top++; // 指向下一个空白位置
}

int CStack::isEmpty()
{
    if (top == 0) // 栈空
    {
        return 1;
    }
    return 0; // 不空
}

int CStack::isFull()
{
    if (top == size) // 栈满
    {
        return 1;
    }
    return 0; // 不满
}

int CStack::pop()
{
    top--; // 指向栈顶数据
    return a[top]; // 把数据返回
}

CStack::~CStack()
{
    cout << "Destructor." << endl;
    delete[] a;
}

int main()
{
    int t, i, n, j, x, result;
    cin >> t; // 组数

    for (i = 0; i < t; i++)
    {
        cin >> n; // 栈的大小
        CStack aa(n);
        for (j = 0; j < n; j++)
        {
            cin >> x;
            aa.push(x); // 进栈
        }
        for (j = 0; j < n; j++)
        {
            if (aa.isFull()) // 如果栈是满的
            {
                result = aa.pop();
                cout << result;
            }
            else if (aa.isEmpty()) // 如果栈是空的
            {
                result = aa.pop();
                cout << result << endl;
            }
            else // 中间的元素
            {
                result = aa.pop();
                cout << " " << result;
            }
        }
        cout << endl;
    }

    return 0;
}
SpongeG
关注
  • 17
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++笔试.zip_C++_C++笔试题
07-15
学习C++笔试题，让你尽可能快速的掌握这门语言
C++ 点圆运算（构造与析构）
hhhertzzz的博客
04-16 1915
题目描述 设计一个点类Point，包含私有属性x坐标和y坐标，操作包括 1、构造函数，要求满足两个条件：1.能够使用类Point去创建一个对象数组（缺省构造方法！）；2.能够接收外来输入的x和y坐标做初始化，提示：构造函数重载 2、析构函数，把x坐标和y坐标都清0，并输出信息“point clear” 3、设置(setXY)，接受外来输入，并设置x坐标和y坐标 4、获取x坐标，直接返回x值 5、...
C++|作业训练-析构与构造函数
CODE_WangZIli的博客
04-14 1581
问题背景1 在学习面向对象的程序设计（C++语言描述）过程中，为了加深对构造函数、析构函数，子对象理解，在VS2022平台上实现类的各项操作。 有以下题目： 定义一个车轮类Wheel，有两个成员变量分别为车轮半径W­_Radius，和车轮宽度W_Width，同时定义一个默认构造函数和一个有两个参数的构造函数来输入车轮的半径和宽度来构造车轮，还要包含一个析构函数，同时添加适当的输入和输出函数。定义一个车辆类Vehicle，要求与上次作业做的车辆类相似，成员数据包括上次作业定义的生产厂家，型号，价格，不同是要求
Google.rar_C++ 笔试题_google_笔试_笔试题
09-21
google笔试题，经典的笔试题，在练习中提高！that ‘s all，thank you
50个C、C++面试题_C++_C++面试题_
10-03
50个C/C++面试题，帮你进阶面试大神，轻松拿到offer
CVC.rar_C++ 笔试_C++面试题_c 面试_软件测试_面试
09-24
C,C++ 笔试、面试题目.rar:收集了一些C,C++面试笔试的试题，附有答案。
C++构造函数和析构函数的使用与讲解
08-26
今天小编就为大家分享一篇关于C++构造函数和析构函数的使用与讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 254
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 903
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 619
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 652
对于类类型，如果定义了接受。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 933
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
C++ 练习题四道 hv-LDM
m0_73379721的博客
05-14 358
4.文件操作 查找指定字符。1.判断两个日期间的天数。
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
C++——引用
fax_player的博客
05-17 915
本篇文章主要讲述在C++中关于引用的一些概念及其用法，还有引用与指针的些许区别，希望能够帮助大家理解~
【华为OD机试-C卷D卷-200分】 简易内存池【C++/Java/Python】
goldarmour的博客
05-14 160
请实现一个简易内存池,根据请求命令完成内存分配和释放。 内存池支持两种操作命令，REQUEST和RELEASE，其格式为： REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。 RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
c++ STL 之排序——sort、partial sort、stable sort、merge 详解
zhhg0123的博客
05-16 566
为什么一个讲 sort 的文章还要有一个篇章就叫 sort 呢？难道还有不叫 sort 的排序吗？yes！sort 其实并不完全是用的是快速排序排集合了堆排序和插入排序。sort 会根据不同的数量级别以及不同情况，能自动选用合适的排序方法。一般快速排序一旦分段后的数据量小于某个阀值，为避免递归调用带来过大的额外负荷，便会改用插入排序。而如果递归层次过深，有出现最坏情况的倾向，还会改用堆排序。所以无论元素初始时为何种状态，sort()的平均排序复杂度为均为，具有不错的的性能。
c++ 构造析构友元函数
08-31
在C++中，构造函数和析构函数是用来创建和销毁对象的特殊成员函数。构造函数在对象被创建时调用，而析构函数在对象被销毁时调用。 构造函数具有以下特点： 1. 构造函数的名称与类名称相同。 2. 构造函数没有返回...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值