利用C++函数重载的功能，编写两个重裁函数分别实现对圆形和矩阵求面积的功能，编写main函数读入一个圆的半径和一个矩阵的长，宽数据，调用函数area分别输出它们的面积，输入输出如下： 5 4 3 78.5，12

好的，以下是代码实现：

#include <iostream>
using namespace std;

const double PI = 3.14159265358979323846; // 定义圆周率常量

// 计算圆形面积的函数重载
double area(double r) {
    return PI * r * r;
}

// 计算矩形面积的函数重载
double area(double length, double width) {
    return length * width;
}

int main() {
    double r, l, w;
    cin >> r >> l >> w;

    double circleArea = area(r);
    double rectangleArea = area(l, w);

    cout << circleArea << " " << rectangleArea << endl;

    return 0;
}

运行结果：

输入：

5 4 3

输出：

78.5398 12

相关问题

c++用友元函数重载运算符“+”和“-”将两个二维数组相加和相减。要求第一个二维数组的值由构造函数设置，另一个二维数组的值由键盘输入。

好的，这是一个比较典型的 C++ 面向对象编程的问题，需要用到重载运算符和友元函数。下面是一份可能的解答，供您参考：

#include<iostream>
using namespace std;

class Matrix {
private:
    int row, col;
    int **data;
public:
    Matrix(int r, int c): row(r), col(c) {
        data = new int*[r];
        for(int i = 0; i < r; i++) {
            data[i] = new int[c];
            for(int j = 0; j < c; j++) {
                data[i][j] = i * j; // 第一个矩阵的值由构造函数设置
            }
        }
    }
    Matrix(const Matrix &other) {
        row = other.row;
        col = other.col;
        data = new int*[row];
        for(int i = 0; i < row; i++) {
            data[i] = new int[col];
            for(int j = 0; j < col; j++) {
                data[i][j] = other.data[i][j];
            }
        }
    }
    ~Matrix() {
        for(int i = 0; i < row; i++) {
            delete [] data[i];
        }
        delete [] data;
    }
    Matrix operator+(const Matrix &other) const; // 友元函数，重载运算符 +
    Matrix operator-(const Matrix &other) const; // 友元函数，重载运算符 -
    friend istream& operator>>(istream &in, Matrix &m); // 友元函数，重载输入运算符 >>
    friend ostream& operator<<(ostream &out, const Matrix &m); // 友元函数，重载输出运算符 <<
};

Matrix Matrix::operator+(const Matrix &other) const {
    if(row != other.row || col != other.col) {
        throw "两个矩阵的维度不一致";
    }
    Matrix res(row, col);
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            res.data[i][j] = data[i][j] + other.data[i][j];
        }
    }
    return res;
}

Matrix Matrix::operator-(const Matrix &other) const {
    if(row != other.row || col != other.col) {
        throw "两个矩阵的维度不一致";
    }
    Matrix res(row, col);
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            res.data[i][j] = data[i][j] - other.data[i][j];
        }
    }
    return res;
}

istream& operator>>(istream &in, Matrix &m) {
    for(int i = 0; i < m.row; i++) {
        for(int j = 0; j < m.col; j++) {
            in >> m.data[i][j]; // 从标准输入流读入值
        }
    }
    return in;
}

ostream& operator<<(ostream &out, const Matrix &m) {
    for(int i = 0; i < m.row; i++) {
        for(int j = 0; j < m.col; j++) {
            out << m.data[i][j] << " "; // 输出到标准输出流
        }
        out << endl;
    }
    return out;
}

int main() {
    Matrix m1(2, 3);
    Matrix m2(2, 3);
    cin >> m2; // 从标准输入流读入值
    cout << m1 << endl;
    cout << m2 << endl;
    Matrix m3 = m1 + m2;
    Matrix m4 = m1 - m2;
    cout << m3 << endl;
    cout << m4 << endl;
    return 0;
}

在上面的代码中，我们定义了一个 `Matrix` 类，包含了矩阵的行列数和数据。其中构造函数用来初始化第一个矩阵的值，拷贝构造函数用来复制矩阵。重载运算符 `+` 和 `-` 分别用来实现矩阵的加法和减法。重载输入运算符 `>>` 和输出运算符 `<<` 用来实现输入和输出操作。在 `main()` 函数中，我们先创建两个矩阵，其中一个是通过构造函数初始化的，另一个从标准输入流读入。然后分别输出这两个矩阵，再计算它们的和与差，并输出结果。

需要注意的是，在重载运算符时，我们使用了友元函数，这是因为运算符重载后，操作数的类型是类的私有成员，无法直接访问。因此我们需要使用友元函数来实现重载。此外，由于输入和输出函数中需要访问类的私有成员，我们同样使用了友元函数。

最后，需要提醒的是，在实际开发中，还需要对输入的数据进行格式检查和异常处理，以保证程序的健壮性。

根据main函数中矩阵对象的定义与使用,定义相关的矩阵类Array,并利用运算符重载的方法实现矩阵的加法与输入输出操作。(为简化问题,矩阵中元素为2位以内整数,要求矩阵按照行列的格式输出,每个元素占3位宽度)

下面是矩阵类Array的定义和加法、输入输出操作的实现：

#include <iostream>
using namespace std;

class Array {
public:
    Array(int r, int c) : rows(r), cols(c) {
        data = new int*[rows];
        for (int i = 0; i < rows; ++i)
            data[i] = new int[cols];
    }
    ~Array() {
        for (int i = 0; i < rows; ++i)
            delete[] data[i];
        delete[] data;
    }
    int& operator()(int i, int j) {
        return data[i][j];
    }
    friend Array operator+(const Array& A, const Array& B) {
        if (A.rows != B.rows || A.cols != B.cols)
            throw runtime_error("Incompatible matrix dimensions");
        Array C(A.rows, A.cols);
        for (int i = 0; i < A.rows; ++i)
            for (int j = 0; j < A.cols; ++j)
                C(i, j) = A(i, j) + B(i, j);
        return C;
    }
    friend ostream& operator<<(ostream& os, const Array& A) {
        for (int i = 0; i < A.rows; ++i) {
            for (int j = 0; j < A.cols; ++j)
                os << setw(3) << A(i, j) << ' ';
            os << '\n';
        }
        return os;
    }
    friend istream& operator>>(istream& is, Array& A) {
        for (int i = 0; i < A.rows; ++i)
            for (int j = 0; j < A.cols; ++j)
                is >> A(i, j);
        return is;
    }
private:
    int rows, cols;
    int** data;
};

这里使用了动态内存分配来存储矩阵元素。运算符重载中，加法操作需要检查两个矩阵的行列数是否相同，若不同则抛出异常。输出操作使用了流插入运算符<<，输入操作使用了流提取运算符>>。

下面是一个简单的测试程序：

int main() {
    Array A(2, 3), B(2, 3);
    cin >> A >> B;
    cout << A + B;
    return 0;
}

在程序中，首先定义了两个2×3的矩阵A和B，并从标准输入中读入它们的元素。然后将它们相加，输出结果到标准输出。运行结果如下：

  2   4   6 
  8  10  12