Question

对于一个分配，我必须实现一个C ++构造函数，将另一个类的对象数组作为参数。我无法理解以下内容：

a.h：

class a {
public :
  a(const b &bb);
private :
  b bb_[10];
};

a.cc：

#include "a.h"
#include "b.h"
a::a(const b &bb) {
  *bb_ = bb;
}

它似乎有效，但那里发生了什么？目标是将bb_初始化为b类的10个对象的数组。 b类有一个默认的构造函数。

谢谢！

Answer 1

*bb_只是bb_[0]所以a的构造函数只是将指定的b复制到其内部数组10 b的第一个单元格。

如果要在内部数组bb的所有10个单元格中复制bb_，请执行以下操作：

std::fill(bb_, bb_ + 10, bb);

如果要将10 b的数组复制到内部数组bb_，则需要在构造函数中将参数bb声明为此类数组：

a::a(b bb[10]) {
  std::copy(bb, bb + 10, bb_);
}

最后，如果您要将10 b数组的地址复制到a，则应将bb_简单地声明为指针和参数bb应该更改构造函数中指定的指针：

a.h：

class a {
public :
  a(const b* bb);
private :
  const b* bb_;
};

a.cc：

#include "a.h"
#include "b.h"
a::a(const b* bb) {
  bb_ = bb;
}

Answer 2

上面的代码确实编译了，但我不确定逻辑是否正确。

您会看到，*bb_ = bb; 行仅填充数组的第一个元素。当您取消引用指向数组的指针时，您将获得其第一个元素（在索引0处）。

你想要做的是填满整个数组，而不仅仅是第一个元素：

const int SIZE = 10;   // please use constants for array sizes

class a {
public :
  a(const b (&bb)[SIZE]) ;
private :
  b bb_[SIZE];
};

a::a(const b (&bb) [SIZE]) {
  for (int i = 0; i < SIZE; i++)
      bb_[i] = bb[i];
}

如果您不喜欢构造函数中的循环，则可以使用memcpy()函数将bb中的内存字节复制到数组中：

a::a(b (&bb) [SIZE]) {
  memcpy(bb, bb_, sizeof(bb));
}

另一种方法是使用更安全的替代方案：std::array：

#include <array>

const int SIZE = 10;

class a {
public :
  a(std::array<b, SIZE> bb);
private :
  std::array<b, SIZE> bb_;
};

a::a(std::array<b, SIZE> bb) {
  bb_ = bb;
}

请帮我理解这个基本的C ++类实现

2 个答案: