实验1

任务1

//标准库string,vector,array基础用法
#include<iostream>
#include<string>
#include<vector>
#include<array>
//函数模板
//对满足特定条件的序列类型T对象，使用范围for输出
template<typename T>
void output1(const T & obj) {
    for (autoi : obj)
        std::cout << i << ",";
    std::cout << "\b\b\n";
}
//函数模板
//对满足特定条件的序列类型T对象，使用迭代器输出
template<typename T>
void output2(constT& obj) {
    for (autop = obj.begin(); p != obj.end(); ++p)
        std::cout << *p << ",";
    std::cout << "\b\b\n";
}
//array模板类基础用法
void test_array() {
    using namespace std;
    array<int, 5>x1;//创建一个array对象，包含5个int元素，未初始化
    cout << "x1.size()=" << x1.size() << endl;//输出元素个数
    x1.fill(42);//把x1的所有元素都用42填充
    x1.at(0) = 999;//把下标为0的元素值修改为999
    x1[4] = -999;//把下表为4的元素值修改为-999
    cout << "x1:";
    output1(x1);//调用模板函数output1输出x1
    cout << "x1:";
    output2(x1);//调用模板函数output1输出x1
    array<int, 5>x2{ x1 };
    cout << boolalpha << (x1 == x2) << endl;
    x2.fill(22);
    cout << "x2:";
    output1(x2);
    swap(x1, x2);//交换array对象x1,x2
    cout << "x1:";
    output1(x1);
    cout << "x2:";
    output1(x2);
}
//vector模板类基础用法
voidtest_vector() {
    usingnamespacestd;
    vector<int>v1;
    cout << v1.size() << endl;//输出目前元素个数
    cout << v1.max_size() << endl;//输出元素个数之最大可能个数
    v1.push_back(55);//在v1末尾插入元素
    cout << "v1:";
    output1(v1);
    vector<int>v2{ 1,0,5,2 };
    v2.pop_back();//从v2末尾弹出一个元素
    v2.erase(v2.begin());//删除v2.begin()位置的数据项
    v2.insert(v2.begin(), 999);//在v1.begin()之前的位置插入
    v2.insert(v2.end(), -999);//在v1.end()之前的位置插入
    cout << v2.size() << endl;
    cout << "v2:";
    output2(v2);
    vector<int>v3(5, 42);//创建vector对象，包含5个元素，每个元素值都是
    42
        cout << "v3:";
    output1(v3);
    vector<int> v4(v3.begin(), v3.end() - 2);//创建vector对象，以v3对象的
    [v3.begin(), v3.end() - 2)区间作为元素值
    cout << "v4:";
    output1(v4);
}
//string类基础用法
voidtest_string() {
    usingnamespacestd;
    strings1{ "oop" };
    cout << s1.size() << endl;
    for (auto& i : s1)
        i -= 32;
    s1 += "2023";
    s1.append(",hello");
    cout << s1 << endl;
}
intmain() {
    usingnamespacestd;
    cout << "===========测试1:array模板类基础用法===========" << endl;
    test_array();
    cout << "\n===========测试2:vector模板类基础用法===========" << endl;
    test_vector();
    cout << "\n===========测试3:string类基础用法===========" << endl;
    test_string();
}

实验2

// 一个简单的类T：定义、使用
#include <iostream>
#include <string>
using namespace std;
// 类T的声明
class T {
public:
    T(int x = 0, int y = 0); // 带有默认形值的构造函数
    T(const T & t); // 复制构造函数
    T(T && t); // 移动构造函数
    ~T(); // 析构函数
    void set_m1(int x); // 设置T类对象的数据成员m1
    int get_m1() const; // 获取T类对象的数据成员m1
    int get_m2() const; // 获取T类对象的数据成员m2
    void display() const; // 显示T类对象的信息
    friend void func(); // 声明func()为T类友元函数
private:
    int m1, m2;
public:
    static void disply_count(); // 类方法，显示当前T类对象数目
public:
    static const string doc; // 类属性，用于描述T类
    static const int max_count; // 类属性，用于描述T类对象的上限
private:
    static int count; // 类属性，用于描述当前T类对象数目
};
// 类的static数据成员：类外初始化
const string T::doc{ "a simple class" };
const int T::max_count = 99;
int T::count = 0;
// 类T的实现
T::T(int x, int y) : m1{ x }, m2{ y } {
    ++count;
    cout << "constructor called.\n";
}
T::T(const T & t) : m1{ t.m1 }, m2{ t.m2 } {
    ++count;
    cout << "copy constructor called.\n";
}
T::T(T && t) : m1{ t.m1 }, m2{ t.m2 } {
    ++count;
    cout << "move constructor called.\n";
}
T::~T() {
    --count;
    cout << "destructor called.\n";
}
void T::set_m1(int x) {
    m1 = x;
}
int T::get_m1() const {
    return m1;
}
int T::get_m2() const {
   return m2;
}
void T::display() const {
    cout << m1 << ", " << m2 << endl;
}
// 类方法
void T::disply_count() {
    cout << "T objects: " << count << endl;
}
// 友元函数func()：实现
void func() {
T t1;
t1.set_m1(55);
t1.m2 = 77; // 虽然m2是私有成员，依然可以直接访问
t1.display();
}
// 测试
void test() {
cout << "T class info: " << T::doc << endl;
cout << "T objects max_count: " << T::max_count << endl;
T::disply_count();
T t1;
t1.display();
t1.set_m1(42);
T t2{ t1 };
t2.display();
T t3{ std::move(t1) };
t3.display();
t1.display();
T::disply_count();
}
// 主函数
int main() {
cout << "============测试类T============" << endl;
test();
cout << endl;
cout << "============测试友元函数func()============" << endl;
func();
}

实验3

#include <iostream>
 #include <complex>
 // 测试标准库提供的复数类模板complex
 void test_std_complex() {
 using namespace std;
 complex<double> c1{ 3, 4 }, c2{ 4.5 };
 const complex<double> c3{ c2 };
 cout << "c1 = " << c1 << endl;
 cout << "c2 = " << c2 << endl;
 cout << "c3 = " << c3 << endl;
 cout << "c3.real = " << c3.real() << ", " << "c3.imag = " << c3.imag()<< endl;
 cout << "c1 + c2 = " << c1 + c2 << endl;
 cout << "c1 - c2 = " << c1 - c2 << endl;
 cout << "abs(c1) = " << abs(c1) << endl; // abs()是标准库数学函数，对复数取模
 cout << boolalpha; // 设置bool型值以true/false方式输出
 cout << "c1 == c2: " << (c1 == c2) << endl;
 cout << "c3 == c2: " << (c3 == c2) << endl;
 complex<double> c4 = 2;
 cout << "c4 = " << c4 << endl;
 c4 += c1;
 cout << "c4 = " << c4 << endl;
    }
 int main() {
 test_std_complex();
}

实验4

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class Rect {
private:
    static int size;
public:
    static const string doc;
    static int size_info() {
        return size;
    }
    friend void test();
private:
    double length, width;
public:
    Rect(double l = 2.0, double w = 1.0) : length{ l }, width{ w } {
        size++;
    }
    Rect(const Rect& obj) : length{ obj.length }, width{ obj.width } {
        size++;
    }
    ~Rect() {
        size--;
    }
    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) {
        length *= times;
        width *= times;
    }
    void resize(double l_times, double w_times) {
        length *= l_times;
        width *= w_times;
    }
};
int Rect::size = 0;
const string Rect::doc{ "a simple Rect class" };

void output(const Rect& r) {
    cout << "矩形信息: " << endl;
    cout << fixed << setprecision(2);
    cout << "长: \t" << r.len() << endl;
    cout << "宽: \t" << r.wide() << endl;
    cout << "面积: \t" << r.area() << endl;
    cout << "周长: \t" << r.circumference() << endl;
}

void test() {
    cout << "矩形类信息: " << Rect::doc << endl;
    cout << "当前矩形对象数目: " << Rect::size_info() << endl;
    Rect r1;
    output(r1);
    Rect r2(4, 3);
    output(r2);
    Rect r3(r2);
    r3.resize(2);
    output(r3);
    r3.resize(5, 2);
    output(r3);
    cout << "当前矩形对象数目: " << Rect::size_info() << endl;
}

int main() {
    test();
    cout << "当前矩形对象数目: " << Rect::size_info() << endl;
}

实验5

# include<iostream> 
# include<cmath>

class Complex {
public:
    Complex(double r = 0, double i = 0);
    Complex(const Complex& c);
    ~Complex() {};

    double get_real() const;
    double get_imag() const;

    void add(const Complex& c);
    void show() const;

    friend Complex add(const Complex& c1, const Complex& c2);
    friend bool is_equal(const Complex& c1, const Complex& c2);
    friend double abs(const Complex& c1);

private:
    double real;
    double imag;

};

Complex::Complex(double r, double i) :real{ r }, imag{ i } {}
Complex::Complex(const Complex& c) :real{ c.real }, imag{ c.imag } {}

double Complex::get_real() const { return real; }
double Complex::get_imag() const { return imag; }

void Complex::add(const Complex& c) {
    real += c.real;
    imag += c.imag;
}

void Complex::show() const {
    if (imag > 0)
    {
        std::cout << real << " + " << imag << "i";
    }
    else if (imag < 0)
    {
        std::cout << real << imag << "i";
    }
    else if (imag == 0)
    {
        std::cout << real;
    }
}

Complex add(const Complex& c1, const Complex& c2) {
    double resultreal = c1.real + c2.real;
    double resultimag = c1.imag + c2.imag;
    return Complex(resultreal, resultimag);
}

bool is_equal(const Complex& c1, const Complex& c2) {
    return (c1.real == c2.real) && (c1.imag == c2.imag);
}

double abs(const Complex& c) {
    double x = sqrt(c.real * c.real + c.imag * c.imag);
    return x;
}

void test() {
    using namespace std;

    Complex c1(3, -4);
    const Complex c2(4.5);
    Complex c3(c1);

    cout << "c1 = ";
    c1.show();
    cout << endl;

    cout << "c2 = ";
    c2.show();
    cout << endl;
    cout << "c2.imag = " << c2.get_imag() << endl;

    cout << "c3 = ";
    c3.show();
    cout << endl;

    cout << "abs(c1) = ";
    cout << abs(c1) << endl;

    cout << boolalpha;
    cout << "c1 == c3 : " << is_equal(c1, c3) << endl;
    cout << "c1 == c2 : " << is_equal(c1, c2) << endl;

    Complex c4;
    c4 = add(c1, c2);
    cout << "c4 = c1 + c2 = ";
    c4.show();
    cout << endl;

    c1.add(c2);
    cout << "c1 += c2, " << "c1 = ";
    c1.show();
    cout << endl;
}

int main() {
    test();
}