在c ++中使用unique_ptr的工厂模式

时间:2014-12-03 21:56:59

标签: c++ this factory smart-pointers unique-ptr

我在c ++中有一个旧工厂实现,我想在其中使用唯一指针而不是原始指针。我的代码的最小示例如下。我有一个基类A和一个派生类B。在main()中,我将1传递给create中的A方法,b1的类型现已更改为B

#include <iostream>
#include <map>

class A {
 public:
  A() {}
  virtual void Foo() {}
  std::map<int, A *> &registerType() {
    static std::map<int, A *> map_instance;
    return map_instance;
  }
  A *create(int n) { return registerType()[n]; }
};

class B : A {
 public:
  B() { registerType()[1] = this; }
  void Foo() { std::cout << "I am B!\n"; }
};

static B b0;

int main() {
  A *b1 = new A();
  b1 = b1->create(1);
  b1->Foo();

  return 0;
}

现在,如果我想将原始指针更改为唯一指针,我自然会得到一组错误(以下代码会导致错误):

#include <iostream>
#include <map>
#include <memory>

class A {
 public:
  A() {}
  virtual void Foo() {}
  std::map<int, std::unique_ptr<A>> &registerType() {
    static std::map<int, std::unique_ptr<A>> map_instance;
    return map_instance;
  }
  std::unique_ptr<A> create(int n) { return registerType()[n]; }
};

class B : A {
 public:
  B() { registerType()[1](this); }
  void Foo() { std::cout << "I am B too!\n"; }
};

static B b0;

int main() {
  std::unique_ptr<A> b1(new A());
  b1 = b1->create(1);
  b1->Foo();

  return 0;
}

错误是:

In member function 'std::unique_ptr<A> A::create(int)':
use of deleted function 'std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = A; _Dp = std::default_delete<A>]'
   std::unique_ptr<A> create(int n) { return registerType()[n]; }

In constructor 'B::B()':
no match for call to '(std::map<int, std::unique_ptr<A> >::mapped_type {aka std::unique_ptr<A>}) (B* const)'
   B() { registerType()[1](this); }
                               ^

所以我想知道:

  1. 是否有意在我这样的情况下使用的独特指针? (我认为答案应该是肯定的!)
  2. 我需要将this作为unique_ptr类型传递给registerType方法。我如何将指针的所有权传递给当前实例(this关键字)到unique_ptr? (如果可能或有意。)
  3. 如果在这里使用唯一指针是一个好习惯,我应该如何实现它?

1 个答案:

答案 0 :(得分:4)

首先,如果有人想要实现工厂模式,使用原始指针执行此操作的可接受方式如下:

#include <iostream>
#include <map>

class A;

class A_Factory {
 public:
  A_Factory() {}
  virtual A *create() = 0;
};

class A {
 public:
  A() {}
  static void registerType(int n, A_Factory *factory) {
    get_factory_instance()[n] = factory;
  }
  static A *create(int n) {
    A *A_instance = get_factory_instance()[n]->create();
    return A_instance;
  }
  virtual void setMyID(int n) {}
  virtual void I_am() { std::cout << "I am A\n"; }
  virtual ~A() {}

 protected:
  int MyID;
  static std::map<int, A_Factory *> &get_factory_instance() {
    static std::map<int, A_Factory *> map_instance;
    return map_instance;
  }
};

class B : public A {
 public:
  B() {}
  void Foo() {}
  void I_am() { std::cout << "I am B " << MyID << "\n"; }
  void setMyID(int n) { MyID = n; }
  ~B() {}

 private:
};

class B_Factory : public A_Factory {
 public:
  B_Factory() { A::registerType(1, this); }
  A *create() { return new B(); }
};

static B_Factory b0_factory;

void caller() {}

int main() {
  A *b1 = A::create(1);
  A *b2 = A::create(1);
  b1->setMyID(10);
  b2->setMyID(20);
  b1->I_am();
  b2->I_am();
  delete b1;
  delete b2;

  return 0;
}

A是基类,B是派生类。如果我们将1传递给A::create(int n),则会生成B类型的对象。手动管理内存,没有内存泄漏。

关于帖子中的问题:

  1. YES。 unique_ptr太棒了;尽可能地使用它们!
  2. 根据问题中提出的设计,传递this的所有权是必要的。我想不出一种方法可以通过this的所有权。根据答案中提供的设计,没有必要通过this
  3. 的所有权
  4. 在上面的工厂模式中实现unique_ptr,如下所示:
  5. #include <iostream>
    #include <map>
    #include <memory>
    
     class A;
    
     class A_Factory {
     public:
      A_Factory() {}
      virtual std::unique_ptr<A> create_unique() = 0;
    };
    
     class A {
     public:
      A() {}
      static void registerType(int n, A_Factory *factory) {
        get_factory_instance()[n] = factory;
      }
      static std::unique_ptr<A> create_unique(int n) {
        std::unique_ptr<A> A_instance =
            std::move(get_factory_instance()[n]->create_unique());
        return A_instance;
      }
    
      virtual void setMyID(int n) {}
      virtual void I_am() { std::cout << "I am A\n"; }
      virtual ~A() {}
    
     protected:
      int MyID;
      static std::map<int, A_Factory *> &get_factory_instance() {
        static std::map<int, A_Factory *> map_instance;
        return map_instance;
      }
    };
    
     class B : public A {
     public:
      B() {}
      void Foo() {}
      void I_am() { std::cout << "I am B " << MyID << "\n"; }
      void setMyID(int n) { MyID = n; }
      ~B() {}
    
     private:
    };
    
     class B_Factory : public A_Factory {
     public:
      B_Factory() { A::registerType(1, this); }
      std::unique_ptr<A> create_unique() {
        std::unique_ptr<A> ptr_to_B(new B);
        return ptr_to_B;
      }
    };
    
     static B_Factory b0_factory;
    
     void caller() {}
    
     int main() {
      std::unique_ptr<A> b1 = std::move(A::create_unique(1));
      std::unique_ptr<A> b2 = std::move(A::create_unique(1));
      b1->setMyID(10);
      b2->setMyID(20);
      b1->I_am();
      b2->I_am();
    
      return 0;
    }
    

    如您所见,不需要手动内存管理,内存管理由unique_ptr处理。