Question

我对你如何在C ++中实现类似的东西感到有点难过。我觉得这可能与我的建筑有关假设我在蒙特利尔有一个车库，在这个车库里，有不同的车。我通常会带一个指向基类车的指针。这是问题，然后我想深入复制车库并在迈阿密打开一个。此外，萨博汽车需要有不同的复制构造，但具有相同的签名。 未来会有其他例外。我不知道车库里有什么。这是我到目前为止的代码。

        //base class
        class Car
        {
            public:

                Car(int speed);

            private:
                int speed;

        }
        class Garage
        {
               public:
                      Garage(){};
                      //copy constructor of the garage
                      Garage(const Garage &toCopy)
                      {
                         for(int i=0;i<toCopy.cars.size();i++)
                         {
                         ReceiveCar(*cars[i]);
                         }
                      }
                      vector<std::shared<Car>> cars;
                      template <typename T>
                      T* ReceiveCar()
                      {
                         std::shared_ptr<T> ptr = std::make_shared<T>();
                         cars.push_back(ptr);
                         return ptr.get();
                      }
                      T* ReceiveCar(Car &toCopy)
                      {
                         std::shared_ptr<T> ptr = std::make_shared<T>(toCopy)                     cars.push_back(ptr);
                         return ptr.get();
                       }

            }
      class Saab : public Car
    {
        public:
              Saab(int speed)
                :Car(speed)
              {
                 DoWork();
              };
    }
    class AstonMartin: public Car
    {
        public:
              AstonMartin(int speed)
                  :Car(speed)
              {
                 DoImportantStuff();
              };
              AstonMartin(const AstonMartin& toCopy)
                  :Car(toCopy.speed)
              {
                 DoImportantStuff();
              };
    }

当然，使用的复制构造函数是来自Car的隐式构造函数。对于规则的每个例外，是否可以在ifs / elses之间调用派生类'one而不进行动态转换。也许以某种方式用指针存储每个派生类？ PS：我知道我不应该返回原始指针，但是我的代码中的汽车析构函数是私有的，因此shared_pointers仍然是安全的。

Answer 1

通常的解决方案是使用虚拟clone()方法来调用对象而不是使用复制构造函数。

Answer 2

在继承的上下文中，应将复制构造函数设计为所谓的“虚拟复制构造函数”。这些函数通常称为copySelf，cloneSelf或简单克隆。

以下是使用复制构造函数和虚拟副本构造函数的详细示例：

Constructor Saab
Constructor AstonMartin
Car: Saab speed: 100
Car: AstonMartin speed: 200
Copy Constructor Garage
Copy Constructor Car
Copy Constructor Car
Copy Constructor AstonMartin
Car: Saab speed: 100
Car: AstonMartin speed: 200

产生输出：

startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));

存储可变数量的派生类的可变数量的对象并深度复制它们

2 个答案: