实验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;

 class Rect
 {
     
     
     public:     
     
     Rect(double l=2.0, double w=1.0)
     {
     length=l;
     width=w;
     }
 
    Rect(Rect &genburten)
    {
        
        this->length=genburten.length;
        this->width=genburten.width;
        
    }
     
     
    double len()
    {
        return length;
    }
    double wide()
    {
        return width;
    }
    double area()
    {
        return length*width;
    }
      double circumference()
      {
          
          
      return (width+length)*2;
          
          
      }
     
     void resize(double times)
     {
         length=times*length;
         width=width*times;
     }
     void resize(double l_times, double w_times)
     {
         
         length=l_times*length;
         width=w_times*width;
         
         
         
         
         
     }
     
     int size_info()
     {
         
         static int i=0;
         i++;
         cout<<i<<endl;
         
     }
     
     char* doc()
     {
         return "a simpe Rect class";
     }
     
     ~Rect(){};
     
 private:
     double length;
     double width;
     
 };
 
 

// 矩形类Rect的定义
// 待补足
// ×××
// 普通函数：输出矩形信息
void output(const Rect &r) {

 
cout << "矩形信息: " << endl;
cout << fixed << setprecision(2); // 控制输出格式：以浮点数形式输出，小

// 补足代码：分行输出矩形长、宽、面积、周长
// ×××

cout<<"长：   "<<Rect::length <<endl;
cout<<"宽：   "<<Rect::width <<endl;
cout<<"面积： "<<r.area() <<endl; 
cout<<"周长： "<<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;
}

#include <iostream>
#include <cmath>

class Complex {
     private:
         double real;
         double imag;
     public:
         Complex();
         Complex(double real0);
         Complex(double real0,double imag0);
         Complex(const Complex &obj);

         double get_real()const;
         double get_imag()const;
         void show()const;
         void add(const Complex &obj);

         friend Complex add(Complex obj1,Complex obj2);
         friend bool is_equal(const Complex &obj1,const Complex &obj2);
         friend double abs(const Complex &obj);
 };

 Complex::Complex() {
     real=imag=0;
 }
 Complex::Complex(double real0) {
     real=real0;
     imag=0;
 }

 Complex::Complex(double real0,double imag0) {
     real=real0;
     imag=imag0;
 }

 Complex::Complex(const Complex &obj) {
     real=obj.real;
     imag=obj.imag;
 }

 double Complex::get_real()const {
     return real;
 }
 double Complex::get_imag()const {
     return imag;
 }
 void Complex::show()const {
     if(imag!=0)
         std::cout<<real<<imag<<"i";
     else
         std::cout<<real;
 }
 void Complex::add(const Complex &obj) {
    real=real+obj.real;
     imag=imag+obj.imag;
 }

 Complex add(Complex obj1,Complex obj2) {
     obj1.real=obj1.real+obj2.real;
     obj1.imag=obj1.imag+obj2.imag;
     return obj1;
 }
 bool is_equal(const Complex &obj1,const Complex &obj2) {
     if(obj1.real==obj2.real&&obj1.imag==obj2.imag) return true;
     else return false;
 }
 double abs(const Complex &obj) {
     return sqrt(pow(obj.real,2)+pow(obj.imag,2));
 }

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