实验一

• 实验任务二

   

#include<iostream>

using std::cout;
using std::cin;
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::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()
{
    int x, y;
    cin >> x >> y;
    Point p1(x, y);
    p1.show();
    Point p2 = p1; //复制构造函数被调用
    p2.show();
    Point p3{ p2 };//复制构造函数被调用
    p3.show();
    cout << p3.get_x() << endl;
}

•  实验任务三

#include<iostream>
#include<iomanip>
using std::cout;
using std::endl;
//定义时钟类型clock
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 , int s );
    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=0, int s=0) {
    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(8,9,4);
    c1.show_time();

    c1 = reset();
    c1.show_time();

    Clock c2(c1);//复制构造函数被调用
    c2.set_time(7, 5);
    c2.show_time();
}

• 实验任务四

 

#include<iostream>
//定义一个简单抽象类X
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{ 42 } {
    std::cout << "default constructor called." << std::endl;
}
X::~X() {
    std::cout << "destructor called." << std::endl;
}
X::X(int m) :data{ m } {
    std::cout << "constructor called." << std::endl;
}
X::X(const X& obj) :data{ obj.data } {
    std::cout << "copy constructor called." << std::endl;
}
X::X(X&& obj)noexcept :data{ obj.data } {
    std::cout << "move constructor called." << std::endl;
}
void X::show()const {
    std::cout << data << std::endl;
}int main()
{
    X x1;//默认构造函数被编译器自动调用
    x1.show();
    X x2{ 2049 };//构造函数被编译器自动调用
    x2.show();
    X x3{ x1 };//复制构造函数被编译器自动调用
    x3.show();
    X x4{ std::move(x2) };//移动构造函数被编译器调用
    x4.show();
}

line33,调用默认构造函数X();

line35,调用构造函数X(int m);

line37,调用复制构造函数X(const X& obj);

line39,调用移动构造函数X(X&& obj)..

析构函数会在对应对象的作用域最后被调用..例如在main里声明了一个类，那么这个类就会在main结束时被调用..

• 实验五

 

#include<iostream>
#include<iomanip>
class Rectangle {
public:
    Rectangle();
    Rectangle(double l, double w);
    Rectangle(const Rectangle& obj);
    ~Rectangle()=default;
    double len()const { return length; }
    double wide()const { return width; }
    double area() const{ return length * width; }
    double circumference()const { return 2 * (length + width); }
    void resize(double times);
    void resize(double l_times, double w_times);
private:
    double length,width;
};
Rectangle::Rectangle():length{2.0},width{1.0}{}
Rectangle::Rectangle(double l,double w):length{l},width{w}{}
Rectangle::Rectangle(const Rectangle& obj):length{obj.length},width{obj.width}{}
void Rectangle::resize(double times)
{
    length *= times;
    width *= times;
}
 void Rectangle::resize(double l_times, double w_times)
{
    length *= l_times;
    width *= w_times;
}
 void output(const Rectangle& rect) {
     using namespace std;
     cout << "矩阵信息： " << endl;
     cout<<fixed << setprecision(2);
     cout.width(8);
     cout.setf(ios::left);
     cout << "长："  <<rect.len() << endl;
     cout.width(8);
     cout.setf(ios::left);
     cout << "宽："  << rect.wide() << endl;
     cout.width(8);
     cout.setf(ios::left);
     cout << "面积：" << rect.area() << endl;
     cout.width(8);
     cout.setf(ios::left);
     cout << "周长："  <<rect.circumference() << endl;
     cout << endl;
 }
 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);
 }