实验四

#pragma once
#include<iostream>
using namespace std;
class vectorInt {
public:
    vectorInt(int n);
    vectorInt(int n, int value);
    vectorInt(const vectorInt &v0);
    ~vectorInt();
    friend void output(vectorInt& v);
    int& at(int n);
    int get_size();
private:
    int size;
    int* p;
};
vectorInt::vectorInt(int n0) {
    cout << "constructor 1 called." << endl;
    size = n0;
    p = new int[n0];
}
vectorInt::vectorInt(int n0, int value) {
    cout << "constructor 2 called." << endl;
    size = n0;
    p = new int[n0];
    for (int i = 0; i < n0; i++)
        p[i] = value;
}
vectorInt::vectorInt(const vectorInt& v0) {
    cout << "copy constructor called." << endl;
    size = v0.size;
    p = new int[size];
    for (int i = 0; i < size; i++)
        p[i] = v0.p[i];
}
vectorInt::~vectorInt() {
    cout << "destructor called." << endl;
}
int& vectorInt::at(int n) {
   
      int  assert(n >= 0 && n < size);
    return p[n];
}
int vectorInt::get_size() {
    return size;
}
void output(vectorInt& v) {
    for (int i = 0; i < v.size; i++)
        cout << v.at(i) << " ";
    cout << endl;
}

#pragma once

#include <iostream>


using std::cout;
using std::endl;

class Matrix {
public:
    Matrix(int n);                
    Matrix(int n, int m);              
    Matrix(const Matrix &X);       
    ~Matrix();                         

    void set(const double *pvalue);     
    void set(int i, int j, int value); 
    double &at(int i, int j);         
    double at(int i, int j) const;     
    int get_lines() const;          
    int get_cols() const;           
    void print() const;              

private：
    int lines; 
    int cols;  
    double *p；
};



Matrix::Matrix(int n): lines{n}, cols{n}
{
    cout << "Matrix1 called\n";
    p = new double[n * n];   
}

Matrix::Matrix(int n, int m): lines{n}, cols{m}
{
    cout << "Matrix2 called\n";
    p = new double[n * m];
}

Matrix::Matrix(const Matrix &X): lines{X.lines}, cols{X.cols}
{
    cout << "Matrix copy called\n";
    lines = X.lines;
    cols = X.cols;
    p = new double[lines * cols];
    for (int i = 0; i < lines * cols; i++)
    {
        p[i] = X.p[i];
    }
    
}

Matrix::~Matrix()
{
    for(int i=0;i<lines*cols;i++)
            delete[] p;
}

void Matrix::set(const double *pvalue)
{
    for (int i = 0; i < sizeof(pvalue); i++)
    {
        p[i] = pvalue[i];
    }
    
  
}

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

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];
}

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

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