实验1 类和对象_基础编程1

实验一

实验代码： 

// 标准库string, vector, array基础用法

#include <iostream>
#include <string>
#include <vector>
#include <array>

// 函数模板

// 对满足特定条件的序列类型T对象，使用范围for输出

template<typename T>

void output1(const T& obj) {
    for (auto i : obj)
        std::cout << i << ", ";
    std::cout << "\b\b \n";
}
// 函数模板

// 对满足特定条件的序列类型T对象，使用迭代器输出

template<typename T>

void output2(const T& obj) {
    for (auto p = 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模板类基础用法
void test_vector() {
    using namespace std;
    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类基础用法

void test_string() {
    using namespace std;
    string s1{ "oop" };
    cout << s1.size() << endl;
    for (auto& i : s1)
        i -= 32;
    s1 += "2023";
    s1.append(", hello");
    cout << s1 << endl;
}

int main() {
    using namespace std;
    cout << "===========测试1: array模板类基础用法===========" << endl;
    test_array();
    cout << "\n===========测试2: vector模板类基础用法===========" << endl;
    test_vector();
    cout << "\n===========测试3: string类基础用法===========" << endl;
    test_string();
}

 实验二

实验代码：

#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();
}

运行结果：

 实验三

实验代码：

// 一个简单的类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();
}

实验结果：

 实验四

实验代码：

 

 

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

// 矩形类Rect的定义
class Rect {
public:
    // 类属性
    static const char* doc;

    // 对象属性
    double length;
    double width;

    // 构造函数
    Rect(double l = 2.0, double w = 1.0) : length(l), width(w) {
        size++;
    }

    // 复制构造函数
    Rect(const Rect& other) : length(other.length), width(other.width) {
        size++;
    }

    // 析构函数
    ~Rect() {
        size--;
    }

    // 普通函数成员
    double len() {
        return length;
    }

    double wide() {
        return width;
    }

    double area() {
        return length * width;
    }

    double circumference() {
        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;
    }

    // 静态成员函数
    static int size_info() {
        return size;
    }

private:
    // 类方法
    static int size;

    // 友元函数
    friend void output(const Rect& rect);
};
const char* Rect::doc = "Rect class to represent rectangles.";
int Rect::size = 0;

void output(const Rect& r) {
    cout << "矩形信息: " << endl;
    cout << fixed << setprecision(2);        // 控制输出格式：以浮点数形式输出，小数部分保留两位
}

        // 补足代码：分行输出矩形长、宽、面积、周长
        void output(const Rect & rect) 
        {
            std::cout << "矩形信息：" << std::endl;
            std::cout << "长度： " << rect.length << std::endl;
            std::cout << "宽度： " << rect.width << std::endl;
            std::cout << "面积： " << rect.area() << std::endl;
            std::cout << "周长： " << rect.circumference() << std::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;
    }

 实验五：

#include <iostream>
#include <cmath>
// 复数类Complex：定义

// 待补足

class Complex{
private:
    double real;
    double imag;
public:
    // 构造函数
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数
    double get_real() const { return real; }
    double get_imag() const { return imag; }

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

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

// 友元函数
friend Complex add(const Complex& a, const Complex& b);
friend bool is_equal(const Complex& a, const Complex& b);
friend double abs(const Complex& a);
};
Complex add(const Complex& a, const Complex& b) {
    return Complex(a.real + b.real, a.imag + b.imag);
}

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

double abs(const Complex& a) {
    return std::sqrt(a.real * a.real + a.imag * a.imag);
}
// 复数类Complex: 测试

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();
}