对象指针的矢量，一般帮助和混淆

指针向量可以重复用于存储子类的对象：

class Person
{
    public:
    virtual const std::string& to_string () = 0;
    virtual ~Person () { } 
};
class Student : public Person
{
   const std::string& to_string ()
   {
       // return name + grade
   }
};
class Employee : public Person
{
   const std::string& to_string ()
   {
      // return name + salary
   }
};
std::vector<Person*> persons;
person.push_back (new Student (name, grade));
person.push_back (new Employee (name, salary));
person[0]->to_string (); // name + grade
person[1]->to_string (); // name + salary

理想情况下，向量应该封装在一个类中。这使得内存管理更加容易。它还便于在不破坏现有客户端代码的情况下更改支持数据结构（此处为std::vector）：

class PersonList
{
   public:
   Person* AddStudent (const std::string& name, int grade)
   {
       Person* p = new Student (name, grade);
       persons.push_back (p);
       return p;
   }
   Person* AddEmployee (const std::string& name, double salary)
   {
       Person* p = new Employee (name, salary);
       persons.push_back (p);
       return p;
   }
    
   ~PersonList ()
   {
      size_t sz = persons.size ();
      for (size_t i = 0; i < sz; ++i)
          delete persons[i];
   }
   private
   std::vector<Person*> persons;
};

因此，我们可以将代码重写为：

{
   PersonList persons;
   Person* student = persons.AddStudent (name, grade);
   Person* employee = persons.AddEmployee (name, salary);
   student.to_string ();
   employee.to_string ();
} // The memory allocated for the Person objects will be deleted when
  // `persons` go out of scope here.

熟悉"三条规则"将有助于您决定何时将复制构造函数添加到类中。另请阅读有关常量正确性的内容。

问题1：你提到了继承。由于继承的对象通常需要更多字节的存储空间，因此它们不适合放置基本对象。如果你试图把它们放进去，你会得到一个基础对象。这称为对象切片。

问题2：先设计，然后再编写代码。有很多可能的解决方案。首先，您可以将它保存在main（）中，但稍后您将被迫创建一个类似PackageContainer的类来保存对象。

问题3+4：当类对象拥有动态分配的对象时，您需要一个复制构造函数、一个赋值运算符=和一个析构函数（三巨头规则）。因此PackageContainer可能需要它们。可以使用new Object(..)动态创建对象。你要负责销毁它们，并在你的指针向量被销毁之前立即将它们的内存还给系统：

for (size_t i = 0; i < shipment.size(); ++i)
{
  delete shipment[i];
}

由于使用指向动态分配对象的裸指针是不安全的，请考虑使用

std::vector<tr1::shared_ptr<Package> > shipment;

而不是

std::vector<std::shared_ptr<Package> > shipment;

如果您的编译器理解C++0x。shared_ptr为您释放内存：它为一个对象指针实现了三大规则。应在生产质量代码中使用。

但也要试着用裸指针把它做好。我想这就是你的家庭作业。

有人告诉我必须使用对象指针的向量，而不是对象。为什么？我的任务特别要求它，但我也被告知否则它不会起作用

通常，人们会避免使用对象向量来避免对象切片的问题。要使多态性发挥作用，必须使用某种指针。我不确定你的赋值中的类是如何对齐的，但你可能在某个地方有继承，因此，如果向量存储基类的对象，并且你在其中插入派生类的对象，那么它会导致派生类成员切片。

最好的解决方案是使用智能指针而不是Raw指针。STL有一个auto_ptr，但不能在标准容器中使用。Boost智能指针将是最好的解决方案，但正如您已经说过的，您不能使用Boost。因此，在您的情况下，您可以使用编译器的智能指针实现，它位于TR1命名空间中，但请记住，在TR1函数的命名空间上存在一些分歧（Visual C++将它们放在std::中，而GCC将它们放进std::tr1::中）。

我应该在哪里创建这个向量？它应该是我的一揽子课程的一部分吗？那么我该如何向其中添加对象呢
您的示例代码已经有一个在向量中添加指向Package类的指针的示例。简而言之，您将动态地为Package分配指针，然后将它们添加到向量中。

我需要复制构造函数吗？为什么
编译器生成的复制构造函数执行成员复制。有时这还不够。例如：

class MyClass {
    public:
        MyClass( const char* str );
        ~MyClass();
    private:
        char* str;
    };
    MyClass::MyClass( const char* str2 )
    {
        str = new char[srtlen( str2 ) + 1 ];
        strcpy( str, str2 );
    }
    Class::~Class()
    {
        delete[] str;
    }

在这种情况下，按成员方式复制str成员不会复制缓冲区（只复制指针（shallow copy）），因此共享缓冲区的第一个要销毁的副本将成功调用delete[]，第二个将运行到Undefined Behavior。在这种情况下，您需要deep copying copy constructor（以及赋值运算符）。

何时使用自定义复制构造函数最好由三规则:定义

Whenever you are writing either one of Destructor, Copy Constructor or Copy Assignment Operator, you probably need to write the other two.

解构对象指针向量的正确方法是什么
您必须在每个包含的指针上显式调用delete来删除它所指向的内容。

vector::erase
从向量容器中移除并调用其析构函数，但如果包含的对象是指针，则它不会拥有销毁它的所有权。

请在此处查看此答案，了解如何正确删除指向对象的指针向量。