编写程序实现(1)用泡法将一个数组排成升序的SUB1函数:(2)在升序数组中插入个数，并且保持该数组仍为升序数组的 SUB2 函数

SUB1函数的实现可以参考下面的代码：

void bubble_sort(int array[], int length) {
    int temp;
    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

而SUB2函数的实现可以参考下面的代码：

void insert_sorted_array(int array[], int length, int num) {
    int i = length - 1;
    while (i >= 0 && array[i] > num) {
        array[i + 1] = array[i];
        i--;
    }
    array[i + 1] = num;
}

这两个函数可以结合使用来完成你所描述的任务。

相关问题

编写子函数：（1）用冒泡法将一个数据组成升序的函数--SUB1;（2）在升序数组中插入一个数，并且保持该数组仍为升序数组的函数--SUB2。 主函数：（1）输入任意10个正整数给数组；（2）调用SUB1对数组进行排序；（3）从键盘输入一个正整数，调用SUB2将其插入该数组

下面是代码实现：

#include <stdio.h>

void SUB1(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void SUB2(int arr[], int n, int x) {
    int i = n - 1;
    while (i >= 0 && arr[i] > x) {
        arr[i + 1] = arr[i];
        i--;
    }
    arr[i + 1] = x;
}

int main() {
    int arr[10];
    printf("请输入10个正整数：\n");
    for (int i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }
    SUB1(arr, 10);
    printf("排序后的数组为：\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n请输入一个正整数：\n");
    int x;
    scanf("%d", &x);
    SUB2(arr, 10, x);
    printf("插入后的数组为：\n");
    for (int i = 0; i < 11; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

解释一下：

`SUB1`函数实现了冒泡排序，将给定的数组升序排列。

`SUB2`函数实现了在升序数组中插入一个数，并且保持该数组仍为升序数组的功能。具体实现是先从数组末尾开始向前遍历，找到第一个比要插入的数小的位置，然后将该位置后面的所有元素都往后移一位，最后将要插入的数插入到该位置后面。

在主函数中，先输入10个正整数，调用`SUB1`对数组进行排序，然后从键盘输入一个正整数，调用`SUB2`将其插入该数组，最后输出插入后的数组。

编一个程序，用成员函数重载运算符“+”和“-”，实现两个二维数组（2*3）相加和相减。要求： (1) 第1个二维数组的值由构造函数设置，另一个二维数组的值由键盘输入。 (2) 定义类array，含有数据成员var为二维数组；成员函数包括：构造函数，getarray()实现键盘输入数组值的功能，display()实现按照行列形式输出数组值的功能，两个成员运算符重载函数实现数组的相加和相减功能。

### 回答1：
这道题目要求实现一个程序，用成员函数重载运算符“+”和“-”，实现两个二维数组（2*3）相加和相减。具体要求：
(1) 第1个二维数组的值由构造函数设置，另一个二维数组的值由键盘输入。
(2) 定义类array，包括数据成员var为二维数组；成员函数包括构造函数，getarray()实现键盘输入数组值的功能，display()实现按行列形式输出数组值的功能，两个成员函数重载运算符实现数组的相加和相减功能。

简单来说，就是实现一个类，包含一个二维数组成员，能够实现二维数组的输入输出和加减运算。其中一个二维数组的值是在构造函数中设置，另一个二维数组的值由键盘输入。通过重载运算符实现了加减运算的功能。

### 回答2：
本程序的需求是使用成员函数重载运算符“+”和“-”，实现两个二维数组（2*3）的加法和减法。

在此前，我们需要定义一个类array来处理这个程序，类array需要包含数据成员var为二维数组，以及构造函数、getarray()、display()和两个成员运算符重载函数addition()和substraction()。

以下是程序示例：

#include<iostream>
using namespace std;

class array {
    private:
        int var[2][3];
    public:
        array() {
            //构造函数，将var数组初始化为0
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    var[i][j] = 0;
                }
            }
        }

        void getarray() {
            //使用键盘输入获取数组的值
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    cin >> var[i][j]; 
                }
            }
        }

        void display() {
            //将数组按行列形式输出
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    cout << var[i][j] << " ";
                }
                cout << endl;
            }
        }

        array operator +(array &a) {
            //定义运算符重载函数“+”用来实现数组相加
            array temp;

            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    temp.var[i][j] = var[i][j] + a.var[i][j];
                }
            }

            return temp;
        }

        array operator -(array &a) {
            //定义运算符重载函数“-”用来实现数组相减
            array temp;

            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    temp.var[i][j] = var[i][j] - a.var[i][j];
                }
            }
            return temp;
        }
};

int main() {
    array a1, a2, a3, a4;
    cout << "请输入第一个二维数组的值：" << endl;
    a1.display();
    cout << "请输入第二个二维数组的值：" << endl;
    a2.getarray();

    a3 = a1 + a2; //使用“+”运算符重载函数，实现数组相加
    a4 = a1 - a2; //使用“-”运算符重载函数，实现数组相减

    cout << "二维数组相加的结果为：" << endl;
    a3.display();
    cout << "二维数组相减的结果为：" << endl;
    a4.display();

    return 0;
}

本程序中，我们先定义了一个类array，并包含了4个成员函数。

在主程序中定义了四个array对象：a1和a2作为两个二维数组，并在键盘输入后分别赋值；a3和a4是使用运算符重载函数“+”和“-”分别实现两个二维数组的加法和减法，并输出结果。

简要解释下运算符重载的含义：运算符重载就是在不同的数据类型（或者同一数据类型的不同实例）之间用相同的运算符进行操作，以实现不同的功能。在本程序中，我们重载了运算符“+”和“-”，以实现数组的加法和减法。

### 回答3：
本题要求编写一个程序，利用成员函数重载运算符" "和"-"，实现两个二维数组（2*3）的加法和减法操作。

首先，需要定义一个类array，其中包括数据成员var为二维数组，成员函数包括构造函数、getarray()实现键盘输入数组值的功能、display()实现按行列形式输出数组值的功能，以及两个成员运算符重载函数实现数组的相加和相减功能。

构造函数中，可以初始化第一个二维数组的值。在getarray()函数中，通过循环输入每一个数组元素的值，以此获得第二个数组的值。在display()函数中，同样通过循环输出每一个数组元素的值，以此实现按行列形式输出数组值的功能。

在成员运算符重载函数中，需要实现"+"和"-"两个操作符的重载。对于"＋"操作符重载函数，通过循环遍历数组元素，将两个数组对应位上的值相加，并存储到新的数组中。对于"-"操作符重载函数，同理，不过需要进行减法操作。

最后，将输入的数组值以及加减结果通过display()函数输出到屏幕上即可。

代码实现如下：

#include<iostream>
using namespace std;
class array
{
public:
    int var[2][3];//数据成员var为二维数组
    array();//构造函数设置第一个二维数组的值
    array getarray();//键盘输入数组值的功能
    void display();//按照行列形式输出数组值的功能
    array operator+(array a);//运算符“+”重载函数，实现数组的相加功能
    array operator-(array a);//运算符“-”重载函数，实现数组的相减功能
};

array::array()//构造函数设置第一个二维数组的值
{
    int n = 1;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            var[i][j] = n;
            n++;
        }
    }
}

array array::getarray()//键盘输入数组值的功能
{
    cout << "请输入数组的值：" << endl;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cin >> var[i][j];
        }
    }
    return *this;
}

void array::display()//按照行列形式输出数组值的功能
{
    cout << "数组值为：" << endl;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << var[i][j] << " ";
        }
        cout << endl;
    }
}

array array::operator+(array a)//运算符“+”重载函数，实现数组的相加功能
{
    array add;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            add.var[i][j] = var[i][j] + a.var[i][j];
        }
    }
    return add;
}

array array::operator-(array a)//运算符“-”重载函数，实现数组的相减功能
{
    array sub;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            sub.var[i][j] = var[i][j] - a.var[i][j];
        }
    }
    return sub;
}

int main()
{
    array arr1;
    arr1.display();
    array arr2;
    arr2.getarray();
    arr2.display();

    array sum = arr1 + arr2;//相加
    sum.display();

    array sub = arr1 - arr2;//相减
    sub.display();

    return 0;
}