class C { public: C(int k = 0) :m_k(k) {} friend int Sum(A& a, B& b,C&c); private: int m_k; };

这段代码定义了一个类C，其中包括一个构造函数和一个友元函数Sum。构造函数初始化了一个私有成员变量m_k，而友元函数Sum可以访问类A、B和C的私有成员。

友元函数Sum的定义如下：

int Sum(A& a, B& b, C& c) {
    return a.m_i + b.m_j + c.m_k;
}

友元函数Sum的作用是计算类A、B和C的私有成员变量m_i、m_j和m_k的和，并返回结果。

需要注意的是，友元函数Sum的声明需要在类C中进行声明，并且在函数名前加上关键字 `friend`，同时在函数声明中添加类名和作用域解析符号 `::`。例如：

class C {
public:
    C(int k = 0) :m_k(k) {}
    friend int Sum(A& a, B& b, C& c);
private:
    int m_k;
};

相关问题

class student {private: int id; // 学号 int score; // 本次考试成绩public: friend double average(student *p, int count);};double average(student *p, int count) { double sum = 0; for (int i = 0; i < count; i++) { sum += p[i].score; } return sum / count;}

这是一个简单的 C++ 程序，定义了一个 `student` 类和一个计算平均成绩的函数 `average`，其中 `average` 函数是 `student` 类的友元函数，可以访问 `student` 类的私有成员。具体来说，`student` 类有两个私有成员变量 `id` 和 `score`，以及一个公有的友元函数 `average`。`average` 函数接收一个 `student` 对象数组 `p` 和一个整数 `count`，计算出 `p` 数组中所有学生的成绩之和，并返回平均成绩。

你可以使用这段代码来创建一个 `student` 对象数组，填充每个学生的学号和成绩，并调用 `average` 函数计算出平均成绩。例如：

int main() {
    const int count = 5;
    student students[count];

    // 填充学生信息
    students[0].id = 1;
    students[0].score = 90;
    students[1].id = 2;
    students[1].score = 85;
    students[2].id = 3;
    students[2].score = 92;
    students[3].id = 4;
    students[3].score = 87;
    students[4].id = 5;
    students[4].score = 95;

    // 计算平均成绩
    double avg = average(students, count);
    cout << "Average score: " << avg << endl;

    return 0;
}

1. 设计矩阵类Matrix（请参照教材page:281矩阵的设计），实现运算符重载。要求： （1）设有两个矩阵A和B，均为3行3列。重载运算符“+”和“*”，使之分别能用于矩阵相加和相乘,C = A+B， C = A*B（30分）。 （2）矩阵能够使用“<<”运算符输出（15分） class Matrix { public: Matrix(int size=2); //构造函数 Matrix(const Matrix &M); //复制构造函数 ~Matrix(); //析构函数 void setMatrix(const int *value); //矩阵赋初值 Matrix operator + (Matrix &m); //重载 + 运算符 Matrix operator * (Matrix &m); //重载 * 运算符 friend ostream &operator << (ostream &out, const Matrix &m); //重载"<<"运算符 int getSize() const {return size;} //得到矩阵大小 int &element(int i,int j) {return elements[i*size+j];}//获取元素 int element(int i,int j) const {return elements[i*size+j];} private: int size; //矩阵的大小 int *elements; //用于存放数组的首地址 }; int main(void) { int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int b[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; Matrix m1(3); m1.setMatrix(*a); Matrix m2(3); m2.setMatrix(*b); Matrix m3 = m1+m2; Matrix m4 = m1*m2; cout << "m3 = " << endl << m3 << endl; cout << "m4 = " << endl << m4 << endl; return 0; }

好的，我明白了你的问题。这是一个关于矩阵类Matrix的运算符重载的问题，要求实现矩阵相加和相乘，并且能够使用“<<”运算符输出矩阵。下面是代码实现：

#include <iostream>
using namespace std;

class Matrix {
public:
    Matrix(int size = 2);                //构造函数
    Matrix(const Matrix &M);           //复制构造函数
    ~Matrix();                             //析构函数
    void setMatrix(const int *value);  //矩阵赋初值
    Matrix operator + (Matrix &m);     //重载 + 运算符
    Matrix operator * (Matrix &m);     //重载 * 运算符
    friend ostream &operator << (ostream &out, const Matrix &m);  //重载"<<"运算符
    int getSize() const { return size; }       //得到矩阵大小
    int &element(int i, int j) { return elements[i*size + j]; }//获取元素
    int element(int i, int j) const { return elements[i*size + j]; }
private:
    int size;           //矩阵的大小
    int *elements;      //用于存放数组的首地址
};

Matrix::Matrix(int size) {
    this->size = size;
    elements = new int[size*size];
}

Matrix::Matrix(const Matrix &M) {
    size = M.size;
    elements = new int[size*size];
    for (int i = 0; i < size*size; i++)
        elements[i] = M.elements[i];
}

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

void Matrix::setMatrix(const int *value) {
    for (int i = 0; i < size*size; i++)
        elements[i] = value[i];
}

Matrix Matrix::operator+(Matrix &m) {
    Matrix result(size);
    for (int i = 0; i < size*size; i++)
        result.elements[i] = elements[i] + m.elements[i];
    return result;
}

Matrix Matrix::operator*(Matrix &m) {
    Matrix result(size);
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            int sum = 0;
            for (int k = 0; k < size; k++)
                sum += elements[i*size + k] * m.elements[k*size + j];
            result.elements[i*size + j] = sum;
        }
    }
    return result;
}

ostream &operator<<(ostream &out, const Matrix &m) {
    for (int i = 0; i < m.size; i++) {
        for (int j = 0; j < m.size; j++)
            out << m.elements[i*m.size + j] << " ";
        out << endl;
    }
    return out;
}

int main(void) {
    int a[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int b[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    Matrix m1(3);
    m1.setMatrix(*a);
    Matrix m2(3);
    m2.setMatrix(*b);
    Matrix m3 = m1 + m2;
    Matrix m4 = m1 * m2;
    cout << "m3 = " << endl << m3 << endl;
    cout << "m4 = " << endl << m4 << endl;
    return 0;
}

希望我的回答能够帮到你！