Question

我无法掌握构造函数，特别是如何在一个内部动态分配数组。有人可能会给出一个具有浮点数数组的类的示例，构造函数接受一个整数arg并动态分配一个数组来保存那么多数字。

其他成员函数将如何访问该数组。

非常感谢您的帮助和任何其他有用的见解。

编辑：我还没学过std：vector，还有更简单的方法吗？

Answer 1

这或多或少是std::vector所做的，虽然这个实现的概率要大得多，所以对于一个新手来说，阅读任何库实现的来源有点困难（特别是考虑到通常是噩梦般的标准库代码中使用的命名约定。

这是宝宝的第一个动态阵列：

class MyArray
{
  float * buf;
  std::size_t size;

public:
  explicit MyArray(std::size_t s) : buf(new float[s]), size(s) { }
  ~MyArray() { delete[] buf; }

  // Copying and reassigning is tricky! We disallow it for now.
  MyArray(MyArray const &) = delete;
  MyArray & operator=(MyArray const &) = delete;

  std::size_t size() const { return size; }
  float & operator[](std::size_t i) { return buf[i]; }
  float const & operator[](std::size_t i)  const { return buf[i]; }
};

这是异常安全的：唯一可能发生异常的是构造函数的初始化列表，并且只有一个这样的场合（new）。如果发生异常，则不会泄露任何内容，因为此时没有其他任何内容被分配。

用法：

MyArray a(20);
a[4] = 6.3;

更高级的版本将包含resize()功能;为此，你必须分配和复制（比如说）：

void resize(std::size_t n)
{
  float * tmp = new float[n];
  std::copy(buf, buf + std::min(size, n), tmp); // I assume this doesn't throw

  delete[] buf;

  buf = tmp;
  size = n;
}

一旦你理解了赋值操作符应该做什么，你就可以使用与resize()非常类似的想法将一个MyArray分配给另一个。{/ p>

Answer 2

struct Array_holder
{
    float* arr;

    Array_holder(size_t size):
    arr(new float[size])
    {}

    ~Array_holder()
    { delete[] arr; }

    float get(size_t i) const
    { return arr[i]; }
};

写这个相当简单的代码我犯了两个粗鲁的错误：

1）我忘了释放记忆 2）如果类有析构函数，我没有实现复制构造函数和赋值运算符，根据3的规则。

这是一个很好的例子，为什么使用动态内存是复杂和危险的。与以下示例比较：

#include <vector>

struct Array_holder
{
    std::vector<float> arr;

    Array_holder(size_t size):
    arr(size)
    {}

    float get(size_t i) const
    { return arr.at(i); }
};

此示例更短，更简单，更易读，更不容易出错，使用更可靠。

Answer 3

首先，因为您使用的是C ++，所以您应该只使用std::vector。

第二

class DynamicArray {
    float* array;
public:
    DynamicArray( int size ) { array = new float[ size ]; }
    ~DynamicArray( void ) { delete[] array; }
    float* get( void ) const { return array; }
};

动态分配数组的构造函数

3 个答案: