实验一：类和对象

1.task2

#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::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(10, 20); // 构造函数被调用
p1.show();

Point p2 = p1; // 复制构造函数被调用
p2.show();

Point p3{p2}; // 复制构造函数被调用
p3.show();

cout << p3.get_x() << endl;
}

 

 

 更换后的测试数据为（10， 20），运行结果如上所示。

 

2.task3

#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 = 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& 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(11, 1, 4); // 构造函数被调用
c1.show_time();
c1 = reset(); // 理论上：复制构造函数被调用
c1.show_time();
Clock c2(c1); // 复制构造函数被调用
c2.set_time(6);
c2.show_time();
}

 

 更换后的Clock对象测试数据为(11, 1, 4),运行结果如上所示。

 

 3.task4

#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{42} {
   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();//42
    
    X x2{2049};    //构造函数
    x2.show();//2049
    
    X x3{x1};    //复制构造函数
    x3.show();//42
    
    X x4{ std::move(x2) };    //移动构造函数 
    x4.show();//2049
    //析构函数被调用4次，销毁和清理对象x1,x2,x3,x4占用的资源 
}

 第42行处默认构造函数被调用，第45行处带一个参数的构造函数被调用，第48行复制构造函数被调用，第51行移动构造函数被调用。

本题，析构函数是在对象生命周期结束，被销毁时被调用，总共被调用了4次，分别销毁和清理了对象x1, x2, x3, x4占用的资源。

 

 4.task5

#include<iostream>
#include<iomanip>

using namespace std;
 
class Rectangle{
public:
    Rectangle();    //默认构造函数
    Rectangle(double l, double w);    //构造函数
    Rectangle(Rectangle& rect);    //复制函数 
    ~Rectangle();    //析构函数 
    
    double len() const { return length; }
    double wide() const { return width; }
    double area() const { return width * length; }
    double circumference() const { return (length + width) * 2; }
    void resize(double times);
    void resize(double l_times, double w_times);

private: 
    double length,width;
};

//Rectangle类的实现 
Rectangle::Rectangle(): length{2.0}, width{1.0} {} 
Rectangle::Rectangle(double l, double w): length{l}, width{w} {}
Rectangle::Rectangle(Rectangle& rect): length{rect.length}, width{rect.width} {}
Rectangle::~Rectangle() {}

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(Rectangle& rect)
{
    cout << "矩形信息：\n"
         << fixed << setprecision(2)    //setprecision(n)与setiosflags(ios::fixed)合用,控制小数点右边的数字个数
         << left << setw(8) << "长：" << rect.len() << endl
                  << setw(8) << "宽：" << rect.wide() << endl
                  << setw(8) << "面积：" << rect.area() << endl
                  << setw(8) << "周长：" << rect.circumference() << endl
                  << 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);
}