实验2 类的定义与应用

最新推荐文章于 2023-05-16 21:33:23 发布

Big-Ben

最新推荐文章于 2023-05-16 21:33:23 发布

阅读量3.5k

点赞数 1

文章标签： C++

本文链接：https://blog.csdn.net/dutmail/article/details/8917702

版权

1、实验目的和要求:

掌握类定义的方法，理解类类型，实例的含义，体会面向对象程序设计中数据隐藏的概念。理解构造函数和析构函数的作用和运行时间，掌握拷贝构造函数的作用。并熟练掌握复杂对象类型的运用。

2、实验内容：

（1）定义一个时间类Time，它能提供由时、分、秒组成的时间。要求能够修改时间和打印出时间。

#include<iostream>
using namespace std;
class time
{
private:
    int hour,minute,second;
public:
    time(int h=0,int m=0,int s=0)
    {
        if(h<0||h>23||m<0||m>59||s<0||s>59)
        {
            cout<<"设定时间错误"<<endl;
        }
        else
        {
            this->hour=h;
            this->minute=m;
            this->second=s;
        }
    }
    ~time() {}
    void setTime()
    {
        int h,m,s;
        cout<<"输入想要修改的时间(h,m,s)"<<endl;
        cin>>h>>m>>s;
        if(h<0||h>23||m<0||m>59||s<0||s>59)
        {
            cout<<"输入时间错误"<<endl;
            return;
        }
        this->hour=h;
        this->minute=m;
        this->second=s;
    }
    void print()
    {
        cout<<hour<<"时"<<minute<<"分"<<second<<"秒"<<endl;
    }
};
int main()
{
    time t;
    cout<<"初始时间为："<<endl;
    t.print();
    t.setTime();
    cout<<"修改后的时间为："<<endl;
    t.print();
}

(2)编写一个计数器类，定义一个私有数据成员，通过两个成员函数，分别使其完成加1和减1操作。用构造函数数据成员初始化为0，输出函数可以输出数据成员的值。

(3)设计一个时间类，要求包含以下功能：

数据成员：时、分、秒

成员函数：

各种重载构造函数

析构函数

可以通过函数分别设置时间的各个组成部分

也可以整体设置时间

有一个tick函数，负责给当前时间加1秒钟，然后输出新的时间

(4) 定义一个分数类如下，要求实现各个成员函数，并在主函数中测试两个分数的加减乘除等运算。

class Rational

{

public:

Rational(int nn=1,int mm=1); //构造函数

Rational R_add(Rational & A); //加

Rational R_sub(Rational & A); //减

Rational R_mul(Rational & A); //乘

Rational R_div(Rational & A); //除

void print(); //以简分数形式显示，注意约分

private:

void simple( ); //约分

int m; //分母

int n; //分子

};

#include<iostream>
#include<stdlib.h>
using namespace std;
class Rational
{
public:
    Rational(int nn=1,int mm=1);       //构造函数
    Rational  R_add(Rational & A);     //加
    Rational  R_sub(Rational & A);     //减
    Rational  R_mul(Rational & A);     //乘
    Rational  R_div(Rational & A);     //除
    void print();                      //以简分数形式显示，注意约分
private:
    void simple();    //约分
    int m;            //分母
    int n;            //分子
};
Rational::Rational(int nn,int mm)
{
    if(mm==0)
    {
        cout<<"分母不能为0"<<endl;
        exit(0);
    }
    this->m=mm;
    this->n=nn;
}
void Rational::simple()
{
    int a=m,b=n,r;
    while(r=a%b)//迭代法计算最大公约数
    {
        a=b;
        b=r;
    }
    m=m/b;
    n=n/b;
}
Rational Rational::R_add(Rational & A)
{
    this->n=n*A.m+m*A.n;
    this->m=m*A.m;
    return *this;
}
Rational Rational::R_sub(Rational & A)
{
    this->n=n*A.m-m*A.n;
    this->m=m*A.m;
    return *this;
}
Rational Rational::R_mul(Rational & A)
{
    this->n=n*A.n;
    this->m=m*A.m;
    return *this;
}
Rational Rational::R_div(Rational & A)
{
    this->n=n*A.m;
    this->m=m*A.n;
    return *this;
}
void Rational::print()
{
    simple();
    cout<<n<<"/"<<m<<endl;
}
int main()
{
    Rational r(3,9);
    r.print();
    Rational p(2,4);
    p.print();
    //测试运算
    r.R_add(p);
    r.print();
    r.R_sub(p);
    r.print();
    r.R_mul(p);
    r.print();
    r.R_div(p);
    r.print();
}

(5) 定义一个类包含一个整型数的指针变量，在构造函数中用new分配10个整型数的内存空间，在析构函数中用delete释放内存空间，并编写给内存空间赋值和输出的成员函数。

#include<iostream>
using namespace std;
class Integer
{
private:
    int *p;
    int size;
public:
    Integer(int size=10)
    {
        this->size=size;
        p=new int[size];//用new分配10个整型数的内存空间
    }
    ~Integer()//用delete释放内存空间
    {
        delete []p;
    }
    void set()
    {
        cout<<"请输入"<<size<<"个整数："<<endl;
        for(int i=0;i<size;i++)
            cin>>p[i];
    }
    void print()
    {
        for(int i=0;i<size;i++)
        {
            cout<<p[i]<<" ";
        }
        cout<<endl;
    }
};
int main()
{
    Integer i;
    i.set();
    i.print();
    return 0;
}

(6) 完成String类

class String

{

public:

String(const char *str = NULL); //普通构造函数

String(const String &other); //拷贝构造函数

~ String(); //析构函数

private:

char *m_data; // 用于保存字符串

};

完成String 的3个成员函数，并编写一个主函数，在主函数中对所编写的成员函数进行测试。

#include<iostream>
#include<cstring>
using namespace std;
class String
{
public:
    String(const char *str = NULL);  //普通构造函数
    String(const String &other);     //拷贝构造函数
    ~ String();                   //析构函数
    void print();
private:
    char *data; // 用于保存字符串
};
String::String(const char *str)
{
    if(str)
    {
        data=new char[strlen(str)+1];
        strcpy(data,str);
    }
    else
    {
        data=new char[8];
        strcpy(data,"<Empty>");
    }
    cout<<data<<" Constructing"<<endl;
}
String::String(const String &other)
{
    if(other.data)
    {
        data=new char[strlen(other.data)+1];
        strcpy(data,other.data);
    }
    else
    {
        data=new char[8];
        strcpy(data,"<Empty>");
    }
    cout<<data<<" Copy Constructing"<<endl;
}
String::~String()
{
    cout<<data<<" Destructing"<<endl;
    delete []data;
}
void String::print()
{
    cout<<"data="<<data<<endl;
}
int main()
{
    String s1("dut");
    String s2(s1);
    String s3;
    s1.print();
    s2.print();
    s3.print();
    return 0;
}

（7）完成Array类

class Array

{

public:

Array(); //所有数组元素初始化为0

int& getData(int i); //返回下标为i的数组元素的引用

void print(); //打印出所有数组元素的值

void input(); //对所有数组元素进行输入

private:

int m_data[10];

};

完成Array 的成员函数，并编写一个主函数，在主函数中对所编写的成员函数进行测试。

#include<iostream>
using namespace std;
class Array
{
public:
    Array();                   //所有数组元素初始化为0
    int& getData(int i);	   //返回下标为i的数组元素的引用
    void print();              //打印出所有数组元素的值
    void input();              //对所有数组元素进行输入
private:
    int data[10];
};
Array::Array()
{
    for(int i=0; i<10; i++)
        data[i]=0;
}
int& Array::getData(int i)
{
    return data[i];
}
void Array::input()
{
    cout<<"Please input 10 numbers"<<endl;
    for(int i=0; i<10; i++)
        cin>>data[i];
}
void Array::print()
{
    for(int i=0; i<10; i++)
        cout<<data[i]<<" ";
    cout<<endl;
}
int main()
{
    Array a;
    a.print();
    a.input();
    cout<<a.getData(5)<<endl;
    a.print();
    return 0;
}

(8) 定义圆类（由圆心坐标点类和半径组成），利用友元函数判断两个圆的位置关系（圆间关系包括相交、相切、相离）。

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

class Point
{
private:
    double x,y;
    friend class Circle;
public:
    Point():x(0),y(0) {}
    Point(double xx,double yy):x(xx),y(yy) {}
};

class Circle
{
private:
    Point center;
    double radius;
public:
    Circle():radius(0) {}
    Circle(double a,double b,double r):center(a,b),radius(r) {}
    void relation(Circle &c1)
    {
        double r=sqrt((c1.center.x-center.x)*(c1.center.x-center.x)+(c1.center.y-center.y)*(c1.center.y-center.y))-(c1.radius+radius);
        if(r>0)
            cout<<"两圆相离"<<endl;
        else if(r==0)
            cout<<"两圆相切"<<endl;
        else
            cout<<"两圆相交"<<endl;
    }
};

int main()
{
    Circle c1(10,10,2),c2(10,14,2);
    c1.relation(c2);
    return 0;
}

(9) 定义类Point.要求定义类对象时，可以有这样的定义语句：

Point p1(1,2),p2(p1);

#include <iostream.h>

class Point

{

public:

Point(int a, int b)

{

x=a;y=b;

}

void fun (Point &p);

void fun (Point * p);

private:

intx,y;

}；

void fun (Point &p)

{

x=p.x ;

y=p.y ;

cout<< "The fun(Point &p)"<<endl ;

}

void Point:: fun (Point *p)

{

x=p->x ;

y=p->y ;

cout<<"Fun (Point *p) "<<endl ;

}

Void main()

{

Pointp(1,2),q(3,4) ;

p.fun(q) ;

q.fun(&q) ;

}

改正程序中小的错误，给出程序运行的结果，并对程序进行分析。

Big-Ben

关注

1
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
实验2 类的定义与应用

1、实验目的和要求: 掌握类定义的方法，理解类类型，实例的含义，体会面向对象程序设计中数据隐藏的概念。理解构造函数和析构函数的作用和运行时间，掌握拷贝构造函数的作用。并熟练掌握复杂对象类型的运用。2、实验内容：（1）定义一个时间类Time，它能提供由时、分、秒组成的时间。要求能够修改时间和打印出时间。#includeusing namespace std;class tim
复制链接

扫一扫