实验一作业

1 #include <iostream>
 2 using namespace std;
 3 // 定义Point类
 4 class Point 
 5 {
 6 public:
 7     Point(int x0 = 0, int y0 = 0);
 8     Point(const Point &p);
 9     ~Point() = default;
10     int get_x() const
11     {
12         return x;
13     }
14     int get_y() const
15     {
16         return y;
17     }
18     void show() const;
19 private:
20     int x, y;
21 };
22 Point::Point(int x0, int y0) :x{ x0 }, y{ y0 }//初始化列表
23 {
24     cout << "constructor called." << endl;
25 }
26 Point::Point(const Point &p)
27 {
28     x = p.x;
29     y = p.y;
30     cout << "copy constructor called." << endl;
31 }
32 void Point::show() const 
33 {
34     cout << "(" << x << ", "<< y << ")" << endl;
35 }
36 
37 int main() 
38 {
39     Point p1(10, 18); // 构造函数被调用
40     p1.show();
41     Point p2 = p1; // 复制构造函数被调用
42     p2.show();
43     Point p3{ p2 }; // 复制构造函数被调用
44     p3.show();
45     cout << p3.get_x() << endl;
46 }

#include <iostream>
#include <iomanip>
using namespace std;
// 定义时钟类Clock
class Clock 
{
public:
    Clock(int h = 0, int m = 0, int s = 0);
    Clock(const Clock &p);
    ~Clock() = default;
    void set_time(int h, int m = 0, int s = 0);
        void show_time() const;
private:
    int hour, minute, second;
};
// 类Clock实现
Clock::Clock(int h, int m, int s) : hour{ h }, minute{ m }, second{ s } 
{
    cout << "constructor called" << endl;
}
Clock::Clock(const Clock &p) : hour{ p.hour }, minute{ p.minute },second{ p.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 
{
    cout << setfill('0') << setw(2) << hour << ":"<< setw(2) << minute << ":"<< setw(2) << second << endl;
}
// 普通函数定义
Clock reset() 
{
    return Clock(0, 0, 0); // 构造函数被调用
}
int main()
{
    Clock c1(20, 22, 30); // 构造函数被调用
    c1.show_time();
    c1 = reset(); // 理论上：复制构造函数被调用
    c1.show_time();
    Clock c2(c1); // 复制构造函数被调用
    c2.set_time(12);
    c2.show_time();
    return 0;
}

#include <iostream>
using namespace std;
// 定义一个简单抽象类
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{ 20 }
{
    cout << "default constructor called.\n";
}
X::~X()
{
    cout << "destructor called.\n";
}
X::X(int m) : data{ m }
{
    cout << "constructor called.\n";
}
X::X(const X &obj) : data{ obj.data }
{
    cout << "copy constructor called.\n";
}
X::X(X &&obj) noexcept : data{ obj.data }
{
    cout << "move constructor called.\n";
}
void X::show() const
{
    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();
    return 0;
}

 

构造函数（按照代码执行顺序）：

  (1)执行X x1代码时，默认构造函数X()被调用

  (2)执行X x2{2022}代码时，构造函数X(int m)被调用，将2022赋值给x2.data

  (3)执行X x3{x1}代码时，复制构造函数被调用，将x1.data赋值给x3.data

  (4)执行X x4{std::move(x2)}代码时，移动构造函数被调用，将x2.data赋值给x4.data 

析构函数：

  对象生命周期结束时，析构函数被调用

  析构函数被调用的顺序与构造函数相反，x4首先调用析构函数，其次x3，然后x2，最后x1

#include <iostream>
#include <iomanip>
// 矩形类Rectangle的定义和实现
class Rectangle
{
public:
    Rectangle();//默认构造函数
    Rectangle(double l, double w);//有参构造函数
    Rectangle(const Rectangle &p);//复制构造函数
    double len();
    double wide();
    double area();
    double circumference();
    void resize(int times);
    void resize(int l_times, int w_times);
    ~Rectangle()
    {

    }//析构函数
private:
    double length;
    double width;
};
Rectangle::Rectangle(double l, double w)
{
    length = l;
    width = w;
}
Rectangle::Rectangle() :length(2.0), width(1.0)
{

}
Rectangle::Rectangle(const Rectangle &p)
{
    length = p.length;
    width = p.width;
}
double Rectangle::len()
{
    return length;
}
double Rectangle::wide()
{
    return width;
}
double Rectangle::area()
{
    return (length * width);
}
double Rectangle::circumference()
{
    return 2*(length + width);
}
void Rectangle::resize(int times)
{
    length = length * times;
    width = width * times;
}
void Rectangle::resize(int l_times, int w_times)
{
    length = length * l_times;
    width = width * w_times;
}
// 普通函数, 用于输出矩形信息
void output(Rectangle &rect) 
{
    using namespace std;
    cout<< "矩形信息:"<<endl;
    cout<< fixed << setprecision(2); // 控制输出格式：以浮点数形式输出、小数部分保留两位
    // 补足代码：分行输出矩形长、宽、面积、周长
    cout<< rect.len() << endl;
    cout << rect.wide() << endl;
    cout << rect.area() << endl;
    cout << rect.circumference() << endl;
    cout << endl;
}
// 主函数，测试Rectangle类
int main() 
{
    Rectangle rect1; // 默认构造函数被调用
    output(rect1);
    Rectangle rect2(10, 5); // 带有两个参数的构造函数被调用
    output(rect2);
    Rectangle rect3(rect1); // 复制构造函数被调用
    rect3.resize(2); // 矩形rect3的长和宽同时缩放2倍
    output(rect3);
    rect3.resize(5, 2); // 矩形rect3的长缩放5倍, 宽缩放2倍
    output(rect3);
    return 0;
}