描述

现在有一个数组类，请实现它的构造函数。

输入描述：

第一行一个整数nn，表示数组的大小。

第二行nn个整数，表示数组。

输出描述：

输出这个数组。

#include <bits/stdc++.h>
using namespace std;

class Array{

    private:
            int n;//数组大小
            int *a;//数组

    public:
//无参构造函数，在构造函数内部读
        Array()
            {
//输入代码cin >> n;和cin >> a[i];直接写在了【构造函数】里，所以不需要外面传参数，构造函数自己从键盘里读数据
                cin >> n;    //读 数组大小
                a = new int[n];// 在构造函数里开辟内存空间
                for(int i = 0;i<n;i++)
                    {
                         cin >> a[i];//读 数组元素
                    }
            }
        
        ~Array()
            {
                delete a[];
            }

            void show()
                    {
        
                        for(int i = 0;i<n;i++)
                            {
                                cou << a[i] << ' ';
                            }
                    }

};


int main()
{

    Array a;//立刻自动调用构造函数，调用后构造函数自己弹出键盘输入，然后就可以直接输入数字
    a.show();
    return 0;
}

#include <iostream>
using namespace std;

class Array{
        private:
            int size;// 数组大小
            int* arr; // 指针 → 指向动态开辟的数组

        public:
            // 1. 构造函数：动态 new 开辟数组（标准写法），有参构造函数
            Array(int n)
                {
                    size = n;
                    arr = new int[size];//动态开辟数组空间
                    cout << "构造函数调用，数组开辟成功" << endl;
                }
            //2.给数组赋值的方法
        void  setValue(int index,int value)
                    {
                        arr[index] = value;
                    }
            // 3. 打印数组
    void showArray() {
        for (int i = 0; i < size; i++) {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

          // 4. 析构函数：自动释放 new 出来的数组

            ~Array()
                {
                    delete[] arr;
                    cout << "析构函数调用，数组内存已释放" << endl;
                }

};


int main()
{
    int n;
    cin >> n;

    // 创建数组对象 → 自动调用【构造函数】，自动 new 数组
    Array obj(n);

    //输入数据

    for(int i=0;i<n;i++)
      {
            int num = 0;
            cin >> num;
            obj.setValue(i,num);
      }
// 输出数组
    obj.showArray();

    // main 结束 → 对象 obj 销毁 → 自动调用【析构函数】
    return 0;
}

上述的无参构造和有参构造，哪种代码耦合性更小？--有参构造

耦合：代码和外部依赖绑死、难以拆分复用。

高耦合：类内部直接读写控制台输入，只能靠键盘输入数据，不能灵活给数组塞自定义数字。

低耦合：类只负责存储数据，输入输出交给 main 主函数，类和控制台完全解绑。

无参构造：类管输入 + 存储，绑死控制台 → 高耦合

有参构造：类只管存储，输入交给 main → 低耦合、标准工程写法