C++ C++；从抽象基类指针复制数据？

假设你有：

class foo {
public:
  virtual int myFunc() = 0;
  ///...
  virtual bool who()   = 0; // don't want to implement this
};

class bar : public foo {
public:
  int myFunc() {return 3;}
  //...
  bool who() {return true;} // don't want to implement this
};

class clam : public foo {
public:
  int myFunc() {return 4;}
  //...
  bool who() {return false;} // don't want to implement this
};


int main() {

  std::vector<foo*> vec (2, NULL);
  vec[0] = new bar();
  vec[1] = new clam();

  // copy vec and allocate new ptrs as copies of the data pointed to by vec[i]
  std::vector<foo*> vec2 (vec.size(), NULL);
  for ( int i=0; i<vec.size(); ++i ) {

    // obviously not valid expression, but it would be nice if it were this easy
    //vec2[i] = new foo(*vec[i]); 

    // the hard way of copying... is there easier way?
    if (vec[i]->who()) {
      vec2[i] = new bar ( * static_cast<bar* >(vec[i]) ) ;
    } else {
      vec2[i] = new clam( * static_cast<clam*>(vec[i]) );
    }

  }

  return 0;
}

class-foo{
公众：
虚拟int myFunc（）=0；
///...
虚拟bool who（）=0；//不希望实现此功能
};
分类栏：公共食品{
公众：
int myFunc（）{return 3；}
//...
bool who（）{return true；}//不想实现这个
};
clam类：公共食品{
公众：
int myFunc（）{return 4；}
//...
bool who（）{return false；}//不想实现这个
};
int main（）{
std：：向量向量向量（2，空）；
vec[0]=新条（）；
vec[1]=新clam（）；
//复制vec并分配新的PTR作为vec指向的数据的副本[i]
std:：vector vec2（vec.size（），NULL）；
对于（int i=0；iwho（））{
vec2[i]=新棒材（*静态铸件（vec[i]）；
}否则{
vec2[i]=新clam（*静态_铸造（vec[i]）；
}
}
返回0；
}

---

我想要的是一些简单的方法，让编译器在簿记中查找，并根据存储的*vec[I]类型分配/复制vec2[I]。解决方法是创建一个虚拟函数，该函数基本上返回一个值，指定*vec[i]的类型，然后在此基础上进行条件分配。

常见的方法如下：

class foo {
public:
  virtual foo* clone() = 0;
};

class bar : public foo {
public:
  virtual bar* clone() { return new bar(*this); }
};

class clam : public foo {
public:
  virtual clam* clone() { return new clam(*this); }
};

---

常见的方法如下所示：

class foo {
public:
  virtual foo* clone() = 0;
};

class bar : public foo {
public:
  virtual bar* clone() { return new bar(*this); }
};

class clam : public foo {
public:
  virtual clam* clone() { return new clam(*this); }
};

---

一种方法是使用动态转换来确定对象的类型，如done here（）。但最简单的方法可能是使用typeid

---

（假设您希望保持使用类型作为限定符的方式，否则我建议使用Joachim或Igor作为更好的替代：）

一种方法是使用动态强制转换来确定对象的类型，如此处所做（）。但最简单的方法可能是使用typeid

---

（假设您希望保持使用类型作为限定符的方式，否则我建议使用Joachim或Igor作为更好的选择：）

您可以使用动态类型转换来向下转换并测试类型

bar* pbar = dynamic_cast<bar*>(vec[i])
if (pbar) {
  vec2[i] = new bar ( * static_cast<bar* >(vec[i]) ) ;
} else {
  vec2[i] = new clam( * static_cast<clam*>(vec[i]) );
}

bar*pbar=dynamic_cast（vec[i]）
中频（pbar）{
vec2[i]=新棒材（*静态铸件（vec[i]）；
}否则{
vec2[i]=新clam（*静态_铸造（vec[i]）；
}

请参阅，以了解动态_cast中的更多信息

---

您可以使用动态强制转换来向下转换和测试类型

bar* pbar = dynamic_cast<bar*>(vec[i])
if (pbar) {
  vec2[i] = new bar ( * static_cast<bar* >(vec[i]) ) ;
} else {
  vec2[i] = new clam( * static_cast<clam*>(vec[i]) );
}

bar*pbar=dynamic_cast（vec[i]）
中频（pbar）{
vec2[i]=新棒材（*静态铸件（vec[i]）；
}否则{
vec2[i]=新clam（*静态_铸造（vec[i]）；
}

请参阅，以了解动态_cast中的更多信息

---

您认为

动态\u cast

操作如何帮助创建/克隆

栏的新最终实例，

foopomter的“clam”？这是一种查找对象类型的方法->查看上面的链接。您认为

dynamic\u cast

操作如何帮助创建/克隆

bar的新最终实例，

clam'和

foo

pomter？这是一种查找对象类型的方法->查看上面的链接。大多数情况下，当您编写

if（对象是某种类型）{do something；}else if（对象是某种其他类型）{do something；}

您应该添加一个新的虚拟函数来封装不同的行为，如Igor的回答所示；大多数时候，当你发现自己在写

if（object是某种类型的）{do something；}else如果（object是某种其他类型的）{do something；}

时，你应该添加一个新的虚拟函数来封装不同的行为，就像Igor的回答一样；这就是他们的目的。