C++中的友元，示例练习

（1）矩阵类的实现

//实现矩阵类
class Matrix{
    //默认私有数据成员：
    int* p_data;//表示矩阵数据
    int row,col;//矩阵的行数和列数
public:
    //01构造函数
    Matrix(int r,int c){
        if(r<=0||c<=0){
            cerr<<"矩阵尺寸不合法！\n";
            exit(-1);
        }
        this->row=r;
        this->col=c;
        this->p_data=new int[row*col];
        //在堆区中开辟一片空间，开辟出来的地址赋值给p_data
    }
    //02析构函数
    ~Matrix(){
        delete []p_data;//将开辟出来的空间归还
    }

    //03访问矩阵元素
    int & element(int i,int j){
        if(i<0||i>=row||j<0||j>=col){
            cerr<<"矩阵下标越界\n";
            exit(-1);
        }
        return *(p_data+i*col+j);///????
    }
/*
 * 在C++中，返回一个数据的引用类型意味着函数返回的不是实际的数据值，
 * 而是数据的引用或别名。这意味着对返回的引用进行的任何更改都会影响原始数据，
 * 因为它们实际上指向相同的内存位置。
 */

   //04访问矩阵元素（为常量对象而提供）
   int element(int i,int j) const{
       if(i<0||i>=row||j<=0||j>=col){
           cerr<<"矩阵下标越界\n";
           exit(-1);
       }
       return *(p_data+i*col+j);//返回位置(i,j)的元素值
   }
   /*
    * 它是一个const成员函数，这意味着它可以被常量对象调用，
    * 并且在函数体内部不会修改对象的成员变量。
    */
   //05获得矩阵的行数
   int dimension_row()const{
       return row;
   }
    //06获得矩阵的列数
    int dimension_column()const{
        return col;
    }
    //07显示矩阵元素
    void display()const{
       int* p=p_data;
       for(int i=0;i 
  
（2）向量类的实现
 
  
//向量类的实现
class Vector{
    int *p_data;
    int num;
public:
    //01构造函数--初始化类的数据成员
    Vector(int n){
        if(n<=0){
            cerr<<"向量尺寸不合法!\n";
            exit(-1);
        }
        num=n;//向量的维度初始化
        p_data=new int[num];//指向开辟数组空间的首地址
    }
    //02析构函数
    ~Vector(){
        delete []p_data;
    }

    //03访问向量元素
    int& element(int i){
        if(i<0||i>=num){
            cerr<<"数组下标越界";
            exit(-1);
        }
        return p_data[i];//返回数据的别名
    }
    //04访问向量元素(为常量对象提供)
    int element(int i)const{
        if(i<0||i>=num){
            cerr<<"数组下标越界";
            exit(-1);
        }
        return p_data[i];//返回数据的别名
    }
    
    //05返回向量尺寸
    int dimension()const{
        return num;
    }
    
    //06显示向量元素
    void display()const{
        int* p=p_data;
        for(int i=0;i 
  
（3）矩阵与向量相乘函数的实现
 
  
//函数Multiply实现矩阵与向量相乘
void Multiply(const Matrix &m,const Vector &v,Vector &r){
    //矩阵m与向量v相乘，结果储存在向量r中，首先检查3个元素的形状是否满足乘法原则
    if(m.dimension_column()!=v.dimension()||m.dimension_row()!=r.dimension()){
        cerr<<"矩阵和向量的尺寸不匹配！\n";
        exit(-1);
    }
    int row=m.dimension_row();
    int col=m.dimension_column();
    //
    for(int i=0;i 
  
（4）在main函数中实现
 
  
int main(){
    int row,col;
    cout<<"请输入矩阵的行数和列数";
    cin>>row>>col;
    //实例化，并调用构造函数初始化一个矩阵类的对象
    Matrix m(row,col);
    Vector v(col);
    Vector r(row);
    
    cout<<"请输入矩阵元素：\n";
    for(int i=0;i>m.element(i,j);
        }
    }
    
    cout<<"请输入向量元素:\n";
    for(int i=0;i>v.element(i);
    
    Multiply(m,v,r);
    
    cout<<"矩阵如下:\n";
    m.display();
    
    cout<<"向量如下:\n";
    v.display();
    
    cout<<"矩阵与向量的乘积为：";
    r.display();
    
    return 0;
}
 
  
（5）声明为友元函数的优化
 
  
上述的函数Multiply中通过多次调用成员函数elment访问m,v和r的元素，每一次调用都要检查下标的合法性，因此效率不高。
 
  
如果把函数multiply作为类Matrix和Vector的友元函数，在函数multiply中直接存取它们的私有成员，将会大大提高效率：
 
  
void multiply(const Matrix &m,const Vector &v,Vector &r){
    //此时相乘函数可以直接操作两个类的私有成员，而不需要再调用它们的成员函数来获取私有成员
    if(m.col!=v.num||m.row!=r.num){
        cerr<<"矩阵和向量的尺寸不匹配！\n";
        exit(-1);
    }
    int *p=m.p_data;
    int *p_r=r.p_data;
    int *p_v;
    
    for(int i=0;i