实验1 类和对象（1）

实验任务2

#include<iostream>
using std::cout;
using std::endl;
class Point
{
    public:
        Point(int x0=0,int y0=0);
        Point(const Point& p);
        ~Point()= default;
        int get_x() const {return x;}
        int get_y() const {return y;}
        void show() const;
    private:
        int x, y;
};
Point::Point(int x0, int y0): x{x0}, y{y0}
{
    cout << "constructor called." << endl;
}
Point::Point(const Point& p): x{p.x}, y{p.y}
{
    cout << "copy constructor called." << endl;
}
void Point::show() const
{
    cout << "(" << x << ", "<< y << ")" << endl;
}
int main()
{
    Point p1(6,6);
    p1.show();
    Point p2 = p1;
    p2.show();
    Point p3{p2};
    p3.show();
    cout << p3.get_x() << endl;
}

实验任务3

#include <iostream>
#include <iomanip>
using std::cout;
using std::endl;
class Clock 
{
    public:
        Clock(int h = 0, int m = 0, int s = 0);
        Clock(const Clock& t);
        ~Clock() = default;
        void set_time(int h, int m = 0, int s = 0);
        void show_time() const;
    private:
        int hour, minute, second;
};
Clock::Clock(int h, int m, int s): hour{h}, minute{m}, second{s}
{
    cout << "constructor called" << endl;
}
Clock::Clock(const Clock& t): hour{t.hour}, minute{t.minute},second{t.second}
{
    cout << "copy constructor called" << endl;
}
void Clock::set_time(int h, int m, int s)
{
    hour = h;
    minute = m;
    second = s;
}
void Clock::show_time() const
{
    using std::setw;
    using std::setfill;
    cout << setfill('0') << setw(2) << hour << ":"<< setw(2) << minute << ":"<< setw(2) << second << endl;
}
Clock reset()
{
    return Clock(0, 0, 0);
}
int main()
{
    Clock c1(10,1,30);
    c1.show_time();
    c1 = reset();
    c1.show_time();
    Clock c2(c1);
    c2.set_time(8);
    c2.show_time();
}

实验任务4

#include <iostream>
class X
{
    public:
        X();
        ~X();
        X(int m);
        X(const X& obj);
        X(X&& obj) noexcept;
        void show() const;
    private:
        int data;
};
X::X(): data{66}
{
    std::cout << "default constructor called.\n";
}
X::~X() {
    std::cout << "destructor called.\n";
}
X::X(int m): data{m} {
    std::cout << "constructor called.\n";
}
X::X(const X& obj): data{obj.data} {
    std::cout << "copy constructor called.\n";
}
X::X(X&& obj) noexcept: data{obj.data} {
    std::cout << "move constructor called.\n";
}
void X::show() const {
    std::cout << data << std::endl;
}
int main() {
    X x1; 
    x1.show();
    X x2{2022};
    x2.show(); 
    X x3{x1}; 
    x3.show();
    X x4{ std::move(x2) };
    x4.show();
}

 分析：

   42行：X x1调用默认构造函数X()，

45行：X x2{2049}调用构造函数X(int m)，

48行：X x3{x1}调用复制构造函数X(const X& obj)，

51行：X x4{ std::move(x2) }调用移动构造函数X(X&& obj) noexcept；

在所有的构造函数都被调用完之后调用析构函数，调用的顺序与构造函数调用的次序相反。

实验任务5

#include<iostream>
#include<iomanip>
using namespace std;
class Rectangle
{
    public:
        Rectangle()=default;
        Rectangle(double l,double w){length=l,width=w;}
        Rectangle(const Rectangle &R);
        double area(){cout << "面积: "<<length*width<<endl;}
        double circumference(){cout << "周长: "<<2*(length+width)<<endl;}
        double resize(int times);
        double resize(int l_times,int w_times);
        double len(){cout<< "长："<<length<<endl;}
        double wide(){cout<< "宽: "<<width<<endl;}
    private:
        double length=2.0,width=1.0;
};
Rectangle::Rectangle(const Rectangle &R)
{
    length=R.length;
    width=R.width;
}
double Rectangle::resize(int times)
{
    length=times*length;
    width=times*width;
}
double Rectangle::resize(int l_times,int w_times)
{
    length=l_times*length;
    width=w_times*width;
}
void output(Rectangle &rect) 
{
    using namespace std;
    cout << "矩形信息: \n";
    cout << fixed << setprecision(2);
    rect.len();
    rect.wide();
    rect.area();
    rect.circumference();
}
int main() 
{
    Rectangle rect1; 
    output(rect1);
    Rectangle rect2(10, 5); 
    output(rect2);
    Rectangle rect3(rect1); 
    rect3.resize(2);
    output(rect3);
    rect3.resize(5, 2); 
    output(rect3);
}

 实验总结：

1.掌握了定义一个类的方法，理解了类中的成员类型，清楚的知道了几类构造函数和析构函数的定义和调用方法以及在计算机内部其调用顺序。

2.加深了对重载函数和形参为引用类型的函数的认识，拓展了对两类函数使用的范围。

3.在编译时出现了“discards qualifiers [-fpermissive]”的错误，经查阅资料后了解到是关键字“const”引起的，但具体原因并不是很清楚，需要进一步了解学习。