类与数组，指针

#pragma once

#include <iostream>
#include <algorithm>

using namespace std;

class vectorInt {
public:
    vectorInt(int len)
        : length{len} {
            cout << "constructor 1 called" << endl;
            p = new int[length];
        }
    vectorInt(int len,int val)
        : length{len} {
            cout << "constructor 2 called" << endl;
            p = new int[length];
            for(int i=0;i<length;i++) {
                *(p+i) = val;
            }
        }
    vectorInt(const vectorInt& v)
        : length{v.length} {
            cout << "copy constructor called" << endl;
            p = new int[length];
            for(int i=0;i<length;i++) {
                *(p+i) = v.at(i);
            }
        }
    ~vectorInt() {
        cout << "destructor called" << endl;
        delete[] p;
    }
    int &at(int i) const{
        return *(p+i);
    }
    int get_size() const {
        return length;
    }
    friend void output(const vectorInt& v) {
        for(int i=0;i<v.length;i++) {
            cout << *(v.p+i) << ", ";
        }
        cout << endl;
    }
private:
    int *p;
    int length;
};

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

#pragma once

#include <iostream>

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

class Matrix {
public:
    Matrix(int n)
        : lines{n},cols{n} {
            p = new double[n*n];
        }                  
    Matrix(int n, int m)
        : lines{n},cols{m} {
            p = new double[n*m];
        }      
    Matrix(const Matrix &X)
        : 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() {
        delete[] p;
    }                     

    void set(const double *pvalue) {
        for(int i=0;i<lines*cols;i++) {
            p[i] = pvalue[i];
        }
    } 
    void set(int i, int j, int value) {
        p[i*cols+j] = value;
    }
    double &at(int i, int j){
        return p[i*cols+j];
    }        
    double at(int i, int j) const {
        return p[i*cols+j];
    }
    int get_lines() const {
        return lines;
    }           
    int get_cols() const {
        return cols;
    }              
    void print() const {
        for(int i=0;i<lines;i++) {
            for(int j=0;j<cols;j++) {
                cout << p[i*cols+j] << ", ";
            }
            cout << endl;
        }
    }                

private:
    int lines; 
    int cols;  
    double *p;
};

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

void test() {
    using namespace std;

    double x[] = {1, 2, 3, 4, 5, 6};

    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 line 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, 111);  
    m3.print();
}

int main() {
    test();
}

实验总结：

声明指针变量时，必须指定指针所指向变量的类型，因为不同的变量类型占用不同的存储空间。一些指针操作需要知道操作对象的大小。另外，程序必须知道储存在指定地址上的数据类型。实参和形参指向同一个地址,他们只是指向相同,指针变量自身的地址却不相同.也就是说当形参新指向了一块新内存时它不能为实参也同样带回一块内存地址。