实验一 类和对象(1)

任务二源代码：

//task2.cpp

#include<iostream>
using std::cout;
using std::endl;

//定义Point类
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(9,8);//构造函数被调用 
     p1.show();
     
     Point p2=p1;//复制构造函数被调用 
     p2.show();
     
     Point p3{p2};//复制构造函数被调用 
     p3.show();
     cout<<p3.get_x()<<endl;
 }

任务二运行结果：

 

任务三源代码：

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

任务三运行结果截图： 

 

 

任务四源代码：

#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();
    
    X x2{2049};
    x2.show();//构造函数被编译器自动调用 
    
    X x3{x1};//复制构造函数被编译器自动调用 
    x3.show();
    
    X x4{std::move(x2)};//移动构造函数被编译器调用 
    x4.show();
}

任务四运行结果截图：

 分析：

1.构造函数的调用及其顺序：line48-49执行时，调用默认构造函数X()；line51-52执行时，调用构造函数X(int m)；line54-55执行时，调用复制构造函数X(const X& obj)；line57-58执行时，调用移动构造函数X(X&& obj) noexcept。

2.当对象被删除前调用析构函数，即在line58执行完后调用析构函数，顺序与构造函数（上一条）相反。

 

实验五代码：

#include<iostream>
#include<iomanip>
class rectangle 
{
public:
    rectangle();
    rectangle(double l, double w);
    rectangle(const rectangle& rect);
    ~rectangle() {}
    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(int times);
    void resize(int l_times, int 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& rect) 
{
    length = rect.length;
    width = rect.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;
}
rectangle output(const rectangle& rect)
{
    using namespace std;
    cout << "矩形信息：" << endl;
    cout << "长：    " << fixed << setprecision(2) << rect.len() << endl;
    cout << "宽：    " << fixed << setprecision(2) << rect.wide() << endl;
    cout << "面积：  " << fixed << setprecision(2) << rect.area() << endl;
    cout << "周长：  " << fixed << setprecision(2) << 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);
}

 

 

运行截图：