实验一

实验任务1

task1_1:

#include <iostream> 
#include <string> 
#include <vector> 
int main() {
	using namespace std;
	string s1;
	string s2{ "c plus plus" };
	string s3{ s2 };
	string s4 = s2;
	s1 = "oop";

	vector<string> v1;
	v1.push_back(s1);
	v1.push_back(s2 + "1");
	v1.push_back(s3 + "2");
	v1.push_back(s4 + "3");

	cout << "output1:" << endl;
	for (auto item : v1) {
		cout << item << endl;
	}

	cout << "output2:" << endl;
	for (auto p = v1.begin(); p != v1.end(); ++p) {
		cout << *p << endl;
	}

	cout << "output3:" << endl;
	for (auto i = 0; i < v1.size(); ++i) {
		cout << v1[i] << endl;
	}

	vector<string> v2{ v1.rbegin(),v1.rend() };

	cout << "v2:" << endl;
	for (auto item : v2) {
		cout << item << endl;
	}
}

　　运行结果：

 task1_2:

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <time.h>

template<typename T>
void output(const T& obj)
{
    for (auto item : obj)
        std::cout << item << " ";
    std::cout << std::endl;
}
int main()
{
    using namespace std;
    vector<int> v1{ 1, 9, 8, 4 };
    v1.insert(v1.begin(), 2022);
    v1.insert(v1.end(), 2023);
    cout << "v1: ";
    output(v1);

    v1.pop_back();
    v1.erase(v1.begin());
    cout << "v1: ";
    output(v1);
    vector<string> v2{ "《1984》", "《动物农场》", "《美丽新世界》" };
    cout << "v2: ";
    output(v2);
}

　　

运行结果：

 

 实验任务2：

 task2:

#include<iostream>
using namespace std;

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(4, 5);
	p1.show();

	Point p2 = p1;
	p2.show();

	Point p3{ p2 };
	p3.show();
	cout << p3.get_x() << endl;
}

　　实验结果：

 实验任务3：

task3：

#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(12, 0, 5);
	c1.show_time(); 

	c1 = reset(); 
	c1.show_time(); 
	
	Clock c2(c1); 
	c2.set_time(6); 
	c2.show_time(); 
}

　　实验结果：

 实验任务4：

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();
  X x2{2049};
  x2.show();
  X x3{x1};
  x3.show();
  X x4{ std::move(x2) };
  x4.show();
}

　　运行结果：

 

 实验任务5：

task5：

#include <iostream>
#include <iomanip>

class  Rectangle {
public:
	Rectangle();
	Rectangle(double l, double w);
	Rectangle(const Rectangle& rect);
	~Rectangle();
	double len() const;
	double wide() const;
	double area() const;
	double circumference() const;

	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& rect) : length{ rect.length }, width{ rect.width }{}

Rectangle::~Rectangle(){}

double Rectangle::len() const {
	return length;
}

double Rectangle::wide() const {
	return width;
}

double Rectangle::area() const {
	return length * width;
}

double Rectangle::circumference() const {
	return 2 * (length + 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 << "矩形信息: \n";
	cout << fixed << setprecision(2);
	
	cout << "矩形的长：  " << left << setw(6) << rect.len() << endl;
	cout << "矩形的宽：  " << left << setw(6) << rect.wide() << endl;
	cout << "矩形的面积：" << left << setw(6) << rect.area() << endl;
	cout << "矩形的周长：" << left << setw(6) << 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);
}

　　运行结果：