实验一

任务一

#include<iostream>
#include<string>
#include<vector>
#include<array>
template<typename T>
void output1(const T &obj)
{
    for(auto i:obj)
      std::cout<<i<<",";
    std::cout<<"\b\b\n"; 
}
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";
}
void test_array()
{
    using namespace std;
    array<int,5> x1;
    cout<<"x1.size()="<<x1.size()<<endl;
    x1.fill(42);
    x1.at(0)=999;
    x1[4]=-999;
    cout<<"x1:";
    output1(x1);
    cout<<"x1:";
    output2(x1);
    array<int,5> x2(x1);
    cout<<boolalpha<<(x1==x2)<<endl;
    x2.fill(22);
    cout<<"x2:";
    output1(x2);
    swap(x1,x2);
    cout<<"x1:";
    output1(x1);
    cout<<"x2:";
    output1(x2); 
}
void test_vector()
{
    using namespace std;
    vector<int>v1;
    cout<<v1.size()<<endl;
    cout<<v1.max_size()<<endl;
    v1.push_back(55);
    cout<<"v1:";
    output1(v1);
    vector<int> v2{1,0,5,2};
    v2.pop_back();
    v2.erase(v2.begin());
    v2.insert(v2.begin(),999);
    v2.insert(v2.end(),-999);
    cout<<v2.size()<<endl;
    cout<<"v2:";
    output2(v2);
    vector<int> v3(5,42);
    cout<<"v3:";
    output1(v3);
    vector<int> v4(v3.begin(),v3.end()-2);
    cout<<"v4:";
    output1(v4);
    
}
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<<"\n===========arry============="<<endl;
    test_array();
    cout<<"\n============vector=========="<<endl;
    test_vector();
    cout<<"\n===========string==========="<<endl;
    test_string();
}

 

任务二

#include <iostream>
#include <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;
  cout << boolalpha;
  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();
}

 

任务三

#include <iostream>
#include <string>
using namespace std;
class T 
{
public:
    T(int x = 0, int y = 0); 
    T(const T &t); 
    T(T &&t); 
    ~T(); 
    void set_m1(int x); 
    int get_m1() const; 
    int get_m2() const; 
    void display() const; 
    friend void func();
private:
    int m1, m2;
public:
    static void disply_count(); 
public:
    static const string doc; 
    static const int max_count; 
private:
    static int count; 
};
const string T::doc{"a simple class"};
const int T::max_count = 99;
int T::count = 0;
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;
}
void func() 
{
    T t1;
    t1.set_m1(55);
    t1.m2 = 77; 
    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:
    static const string doc;
    Rect(double x=2.0,double y=1.0);
    Rect(Rect &r);
    double len(){return length;}
    double wide(){return width;}
    double area(){return(length*width);}
    static int size_info(){return size;}
    double circumference(){return 2*(length+width);}
    void resize(int times);
    void resize(int l_times,int w_times);
    ~Rect();
private:
    double length,width;
    static int size;    
}; 
const string Rect::doc("a simple rect class");
int Rect::size=0;
Rect::Rect(double x,double y)
{
    length=x;
    width=y;
    size++;
}
void Rect::resize(int times)
{
    length=length*times;
    width=width*times;
}
void Rect::resize(int l_times,int w_times)
{
    length=length*l_times;
    width=width*w_times; 
}
Rect::Rect(Rect &r)
{
    length=r.length;
    width=r.width;
    size++;
}
Rect::~Rect()
{
    --size;
}
void output(const Rect &r) 
{
    cout << "矩形信息: " << endl;
    cout << fixed << setprecision(2); 
    Rect a;
    a=r;
    cout<<"长度"<<a.len()<<endl;
    cout<<"宽度"<<a.wide()<<endl; 
    cout<<"周长"<<a.circumference()<<endl;
    cout<<"面积"<<a.area()<<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>
using namespace std;
class Complex
{
public:
    Complex(double a = 0, double b = 0) :a(a), b(b) {}
    Complex(const Complex& x) ;
    double get_real() { return a; }
    double get_imag() const { return b; }
    void show() const;
    void add(const Complex &z);
    ~Complex(){};
    friend Complex add(const Complex &k,const Complex &l);
    friend bool is_equal(const Complex &asd,const Complex &zxc);
    friend double abs(const Complex &x);

private:
    double a, b;
};
Complex::Complex(const Complex& x)
{
    a = x.a;
    b = x.b;
}
void Complex::show() const
{
    if (b > 0)
        cout << a << "+" << b << "i" ;
    else if (b < 0)
        cout << a << b << "i" ;
    else
        cout << a ;
}
void Complex::add(const Complex &z)
{
    a = a + z.a;
    b = b + z.b;
}
Complex add(const Complex &k,const Complex &l)
{
    Complex s;
    s.a=k.a+l.a;s.b=k.b+l.b;
    return (s);
}
bool is_equal(const Complex &asd,const Complex &zxc)
{
    if (asd.a == zxc.a && asd.b == zxc.b)
        return (true);
    else
        return (false);
}
double abs(const Complex &x)
{
    return(sqrt(x.a * x.a + x.b * x.b));
}


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