在C ++中使用unique_ptr的工厂模式 [英] Factory pattern using unique_ptr in c++
问题描述
我在C ++中有一个旧的工厂实现,我想在其中使用唯一的指针而不是原始指针.我的代码的一个最小示例如下.我有一个基类A
和一个派生类B
.在main()
中,我将1
传递给A
中的create
方法,并且b1
的类型现在更改为B
.
I have an old factory implementation in c++, and I want to use unique pointers instead of raw pointers in it. A minimal example of my code is as follows. I have a base class A
, and a derived class B
. In main()
, I pass 1
to the create
method in A
, and the type of b1
is now changed to B
.
#include <iostream>
#include <map>
class A {
public:
A() {}
virtual void Foo() {}
std::map<int, A *> ®isterType() {
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;
}
现在,如果我想将原始指针更改为唯一指针,我自然会得到一个错误集合(以下代码会导致错误):
Now if I want to change raw pointers to unique pointers, I naturally get a collection of errors (the following code results in errors):
#include <iostream>
#include <map>
#include <memory>
class A {
public:
A() {}
virtual void Foo() {}
std::map<int, std::unique_ptr<A>> ®isterType() {
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); }
^
所以我想知道:
- 在我的情况下是否打算使用唯一的指针? (我认为响应应该是!)
- 我需要将
this
作为unique_ptr
类型传递给registerType
方法.如何将指向当前实例的指针的所有权(this
关键字)传递给unique_ptr
? (如果有可能或有意成为可能.) - 如果在这里使用唯一指针是一种好习惯,那么我应该如何实现呢?
- Were unique pointers intended to be used in cases like mine? (I assume the response should be yes!)
- I need to pass
this
as aunique_ptr
type to theregisterType
method. How I can pass the ownership of the pointer to the current instance (this
keyword) to aunique_ptr
? (If it is possible or was intended to be possible.) - If it is a good practice to use unique pointers here, how I should implement it?
推荐答案
首先,如果有人要实现工厂模式,则可以使用原始指针来实现此目的,如下所示:
First of all, if someone wants to implement a factory pattern, an acceptable way of doing it with raw pointers is as follows:
#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
的对象.内存是手动管理的,不会有内存泄漏.
A
is the base class, and B
is the derived one. If we pass 1
to A::create(int n)
, an object of type B
will be produced. The memory is managed manually and there would be no memory leak.
关于帖子中的问题:
- 是的. unique_ptr太棒了;尽可能使用它们!
- 使用问题中提出的设计,必须以某种方式传递
this
的所有权.我想不出一种方法来传递this
的所有权.使用答案中提出的设计,不必传递this
的所有权. - 以上述工厂模式实施unique_ptr,如下所示:
- YES. unique_ptr is awesome; use them wherever you can!
- With the design presented in the question, passing the ownership of
this
was somehow necessary. I cannot think of a way to pass the ownership ofthis
. With the design presented in the answer, it is not necessary to pass the ownership ofthis
. - Implement the unique_ptr in the above factory pattern as below:
#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
处理.
As you can see, no manual memory management is necessary and the memory management is handled by the unique_ptr
.
这篇关于在C ++中使用unique_ptr的工厂模式的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!