如何通过构造函数将指向对象的指针数组复制到ClassA类中？

原代码的核心错误 #

1. 类型不匹配：参数classBs是const ClassB*[]类型，意味着数组里的每个元素是指向const ClassB的指针；而成员变量m_classBs是ClassB**，指向的是可修改的ClassB指针，直接赋值会触发const权限放大的编译错误。
2. 错误的地址操作：&classBs[i]取的是指针本身的地址（类型为const ClassB**），而不是你需要的classBs[i]存储的指针值（类型为const ClassB*）。

正确的浅拷贝实现（复制指针数组，不复制对象） #

如果你的需求只是复制指针本身（即两个数组的指针指向同一个ClassB对象），需要先修正成员变量的类型以匹配const权限，再调整赋值逻辑：

// ClassA.h
class ClassA {
  const ClassB** m_classBs{}; // 改为const ClassB**，匹配参数类型
public:
  ClassA(const ClassB* classBs[], size_t cnt);
  ~ClassA(); // 必须添加析构函数释放内存
};

// ClassA.cpp
ClassA::ClassA(const ClassB* classBs[], size_t cnt) {
  m_classBs = new const ClassB*[cnt]; // 分配对应类型的指针数组
  for (size_t i = 0; i < cnt; ++i) {
    m_classBs[i] = classBs[i]; // 直接复制指针值，无需取地址
  }
}

ClassA::~ClassA() {
  delete[] m_classBs; // 释放数组内存，注意是delete[]不是delete
}

如果必须让m_classBs保持ClassB**类型（即需要修改指向的ClassB对象），则需要确保传入的classBs数组本身指向非const对象，此时可以将参数改为ClassB* classBs[]，再按上述逻辑赋值。

深拷贝实现（复制指针指向的对象） #

如果你的需求是复制每个ClassB对象本身（即新数组的指针指向独立的ClassB实例），则需要在循环中创建新对象，前提是ClassB有可用的拷贝构造函数：

// ClassA.h
class ClassA {
  ClassB** m_classBs{};
  size_t m_cnt; // 保存数组长度，用于析构时释放对象
public:
  ClassA(const ClassB* classBs[], size_t cnt);
  ~ClassA();
};

// ClassA.cpp
ClassA::ClassA(const ClassB* classBs[], size_t cnt) : m_cnt(cnt) {
  m_classBs = new ClassB*[cnt];
  for (size_t i = 0; i < cnt; ++i) {
    m_classBs[i] = new ClassB(*classBs[i]); // 调用ClassB的拷贝构造函数创建新对象
  }
}

ClassA::~ClassA() {
  // 先释放每个ClassB对象
  for (size_t i = 0; i < m_cnt; ++i) {
    delete m_classBs[i];
  }
  delete[] m_classBs; // 再释放数组内存
}

现代C++更优方案：使用std::vector替代裸指针数组 #

手动管理裸指针数组容易出现内存泄漏、越界等问题，推荐用std::vector来简化操作：

// ClassA.h
#include <vector>

class ClassA {
  std::vector<const ClassB*> m_classBs; // 用vector存储指针，自动管理内存
public:
  ClassA(const ClassB* classBs[], size_t cnt);
};

// ClassA.cpp
ClassA::ClassA(const ClassB* classBs[], size_t cnt)
  : m_classBs(classBs, classBs + cnt) {} // 直接用vector的范围构造函数完成复制

这种方式无需手动写析构函数，vector会自动释放内存，同时避免了裸指针的各种风险。

内容的提问来源于stack exchange，提问作者Sebastian Rubina