实验四

1cpp

#include<iostream>
#include"point.hpp"
#include<vector>

using namespace std;

void test1()
{
    int n;
    cin >> n;
    
    vector<Point> x(n);
    x.at(0).show();
    x.at(0).move(30,50);
    x.at(0).show();
}

void test2()
{
    int n;
    cin >> n;
    vector<Point> x(n);
    
    vector<Point> y(x);
    y.at(0).show();
    
    x.at(0).move(50,60);
    
    x.at(0).show();
    y.at(0).show();
}

int main()
{
    test1();
    test2();
    return 0;
}

1hpp

#pragma once
#include<iostream>

using namespace std;

class Point {
    public:
        Point(): x{0},y{0} {}
        Point(int x0,int y0): x{x0}, y{y0} {}
        ~Point() = default;

        int get_x() const;
        int get_y() const;
        void show() const;
        void move(int new_x,int new_y);

    private:
        int x,y;
};

int Point::get_x()const {
     return x;
}

int Point::get_y()const {
     return y;
}

void Point::move(int new_x,int new_y)
{
  x = new_x;
  y = new_y;
}

void Point::show()const {
    cout << "(" << x << "," << y << ")" << endl;
}

5.cpp

#include <iostream>
#include "vectorInt.hpp"
 void test() {
    using namespace std;
    int n;
     cin >> n;
     vectorInt x1(n);
     for (auto i = 0; i < n; ++i)
         x1.at(i) = i * i;
     
    output(x1);
     vectorInt x2(n, 42);
    vectorInt x3(x2);
    output(x2);
    output(x3);
    x2.at(0) = 77;
    output(x2);
    output(x3);
}
int main() {
    test();
}

5.hpp

#pragma once

#include <iostream>
using namespace std;
class vectorInt{
    public:
    vectorInt(int n);
    vectorInt(int n,int value);
    vectorInt( vectorInt& T);
    ~vectorInt();
    int &at(int i);
    int get_size();
    friend void output(vectorInt &T);
    private:
    int* p;    int size;
};
vectorInt::vectorInt(int n):size{n}{
    p=new int[n];
    for(int i =0 ;i < n;i ++){
        p[i]=0;
    }
    cout<<"constructor 1 called.\n";
}
vectorInt::vectorInt(int n,int value):size{n}{
        p=new int[n];

    for(int i=0;i<size;++i){
        p[i]=value;
    }
    cout<<"constructor 2 called.\n";
}
vectorInt::vectorInt( vectorInt& T){
    this->p=new int[T.size];
    this->size=T.size;
    for(int i=0;i<size;++i){
        this->p[i]=T.at(i);
    }
cout<<"copy constructor called.\n";
}
int &vectorInt::at(int i){
    return p[i];
}
int vectorInt::get_size(){
    return size;
}
void output(vectorInt &T){
    for(int i=0;i<T.get_size();++i){
    cout<<T.at(i)<<", ";
    }
    cout<<"\b\b \n";
}
vectorInt::~vectorInt(){
    delete [] p;
    cout<<"destructor called.\n";
}

6.cpp

#include<iostream>
#include"Matrix.hpp"

using namespace std;

void test() {
    
    double x[] = {1,2,3,4,5,6};
  //  for(int i = 0; i < 6;i ++)
     //   cout << x[i] << endl;
    
    Matrix m1(3, 2);
    m1.set(x);
    m1.print();
    
    
    cout << "the first line is: " << endl;
    cout << m1.at(0,0) << " " << m1.at(0,1) << endl;
    
    cout << endl;
    
    Matrix m2(2, 3);
    m2.set(x);
    m2.print();
    cout << "the first lint is: " << endl;
    cout << m2.at(0, 0) << " " << m2.at(0, 1) << " " << m2.at(0, 2) << endl;
    cout << endl;
    
    Matrix m3(m2);
    m3.set(0,0,999);
    m3.print();

}
int main()
{
    test();
    return 0;
}

6.hpp

#pragma once
#include<iostream>

using namespace std;

class Matrix {
public:
    Matrix(int n);
    Matrix(int n,int m);
    Matrix(const Matrix &x);
    ~Matrix();
    void set(const double *pv);
    
    void set(int i,int j,int v);
    double &at(int i,int j);
    double at(int i,int j)const;
    int get_lines()const;
    int get_cols()const;
    void print()const;
   // int tolink(int i,int j);
    
private:
    int lines;
    int cols;
    double *p;
    
};

Matrix::Matrix(int n) : lines{n},cols{n}
{
    p = new double[n * n];
}

Matrix::Matrix(int n,int m) : lines{n},cols{m}
{
    p = new double[n * m];
}

Matrix::Matrix(const Matrix &x)
{
    this->p = new double[x.lines * x.cols];
    this->lines = x.lines;
    this->cols = x.cols;
    int t = 0;
    for(int i = 0;i < lines ;i ++)
        for(int j = 0;j < cols ;j ++)
            p[t ++] = x.at(i,j);
            
}

Matrix::~Matrix(){
    delete []p;
}

void Matrix::set(const double *pv)
{
    for(int i = 0;i < lines * cols ;i ++)
       p[i] = pv[i];

}

void Matrix::set(int i,int j,int v)
{
    p[i * cols + j] = v;
}

double &Matrix::at(int i,int j)
{
    return p[i * cols + j];
}

double Matrix :: at(int i,int j)const{
    return p[i * cols + j];
}

inline int Matrix ::get_lines()const
{
    return lines;
}

inline int Matrix :: get_cols()const
{
    return cols;
}

void Matrix::print()const
{
    for(int i = 0;i < lines;i ++)
    {  for(int j = 0;j < cols;j ++)
        cout << p[i * cols + j] << " ";
        cout << endl;
    }
    
   // for(int i = 0;i < lines * cols ;i ++)
       // cout << p[i] << endl;
}