如何声明一个包含整数数组的对象

Question

(C++)您好，我在声明对象时遇到了问题，让我们先看一下它的代码：

```c++ ```

class arr1D
{
protected:
    int size;
    int *arr;
public:
    arr1D( int a[] ):size(sizeof(a)/sizeof(a[0])), arr(new int[size])
    {
        for(int i = 0; i < size; i++)
        {
            arr[i] = a[i];
        }
    }
    arr1D( int siz = 10 ):size(siz), arr(new int[size])
    {
        for( int i = 0; i < size; i++)
        {
            arr[i] = 0;
        }
    }
    friend ostream & operator<<( ostream &,const arr1D &);
};
int main()
{
    //arr1D *a1 = new arr1D;
    //cout << *a1;
    //prints "arr: 0 0 0 0 0 0 0 0 0 0 size: 10"
    return 0;
}
ostream & operator<<( ostream &_return, const arr1D &a)
{
    _return << "arr: ";
    for(int i=0;i<a.size;i++)
    {
        cout << *(a.arr+i) << " ";
    }
    _return << "size: " << a.size;
    return _return;
}

我想声明一个包含整数数组的对象，类似于这样：

arr1D a1[] = {1,2,3,4,5}; // pseudo-code

这应该会打印出类似于这样的东西：

arr: 1 2 3 4 5 size: 5

感谢您的帮助！

- justanordinaryguy

---

可能是 https://dev59.com/FWDVa4cB1Zd3GeqPhNvG 的重复问题。 - Galik

我从未使用过向量，现在我正在尝试用这种方式解决它。有什么想法吗？ - justanordinaryguy

不相关的，析构函数在哪里？ - JeJo

https://dev59.com/QW855IYBdhLWcg3w1oE8 - Abdul Ahad

我从未使用过向量，但是开始使用vector永远不会太早。忘记[]数组的存在吧。此外，你不需要使用new来创建对象。std::vector<int> a1 = { 1, 2, 3, 4, 5 };就足够了。 - Caleth

Answer 1

我希望声明一个包含整数数组的对象，类似于这样的伪代码: "arr1D a1[] = {1,2,3,4,5};" 这应该打印出类似于这样的东西: "arr: 1 2 3 4 5 size: 5" 感谢您的帮助！

您可以在类中使用初始化列表构造函数来实现。

类似以下内容：

#include <iostream>
#include <initializer_list>

class arr1D
{
protected:
    int size;
    int *arr;
public:
    arr1D(std::initializer_list<int> input) : size(input.size())
    {
        int* temp = new int[size];
        int index = 0;
        for (const auto& it : input)
        {
            temp[index] = it;
            ++index;
        }
        arr = temp;
    }
        // reaming code...

请点击这里查看实时演示。

请注意，在arr1D类中还需要一个析构函数，否则由于类中有指针成员，会导致内存泄漏。

---

作为替代方案，使用智能指针，这是处理动态内存的聪明方式，可以在堆中分配。

查看一个示例解决方案这里。

#include <iostream>
#include <initializer_list>
#include <memory>

class arr1D
{
protected:
    int size;
    std::unique_ptr<int[]> arr;
public:
    arr1D(std::initializer_list<int> input) : size(input.size())
    {
        arr = std::unique_ptr<int[]>(new int[size]);
        int index = 0;
        for (const auto& it : input)
        {
            arr[index] = it;
            ++index;
        }
    }
    .......
    .......
std::ostream & operator<<(std::ostream &_return, const arr1D &a)
{
    _return << "arr: ";
    for (int i = 0; i< a.size; i++)  std::cout << a.arr[i] << " ";

    _return << "size: " << a.size;
    return _return;
}

---

PS: 然而，这更适合处理 std::vector<>。如果您不知道它的工作原理，请参见 this question。 Edit: 正如 @M.M 提到的，通过值传递 std::initializer_list 而不是通过引用传递更加合适，因此编辑了类的构造函数。

- JeJo

---

std::initializer_list 应该按值传递。请参见此处。 - M.M

@M.M 感谢您的回答。这对我来说很有趣。const& 实际上是我的习惯，但并不适用于所有情况。我会进行编辑。 - JeJo