我有两个类A
和B
。我从A
中确定地计算B
。对于每个A
,只要my_B
存在,我就想跟踪B
。一旦B
被破坏,我希望将my_B
更改为类似nullptr
.
class A{
// stuff
public:
B ComputeB(){
if (my_B is null){
B result = B(A);
my_B = B; // some kind of reference
return B(A);
}
else {
return my_B;
}
}
~A(){ /* Do I need a destructor? */ }
private:
WhatTypeHere my_B;
}
当B
被破坏时,什么会导致my_B
引用nullptr
(或WhatTypeHere
的等价物)?
使用 shared_ptr 和 weak_ptr
为了使B
对象在A
中保持活动状态,只要它仍在使用中,您应该有一个数据类型A
的数据成员std::weak_ptr<B>
这将允许访问创建的B
对象,只要它处于活动状态。
来自computeB
的返回值将是std::shared_ptr<B>
,如果后者持有nullptr
,则该值将从std::weak_ptr<B>
成员获取或创建。
线程安全
创建或获取现有B
的决定应该是线程安全的。为此,您应该尝试使用lock()
方法获取weak_ptr
持有的实际B
,然后仅当返回值nullptr
创建一个新值时。
代码如下所示:
class A {
// stuff
public:
std::shared_ptr<B> ComputeB() {
std::shared_ptr<B> shared_b = my_B.lock();
if (!shared_b){
shared_b = std::make_shared<B>(*this);
my_B = shared_b;
}
return shared_b;
}
// no need for a destructor, unless "stuff" needs one
// ~A(){}
private:
std::weak_ptr<B> my_B;
};
<小时 />复印和分配
上述类在复制和赋值中的行为是有问题的,因为默认的复制构造函数和默认赋值运算符将执行成员级复制/赋值,这可能导致两个不同的A
持有对同一B
的weak_ptr
。这很可能不是你想要的,特别是如果A
是可变的(即可以改变其内在值)。
为了提供用于复制和赋值的建议代码,让我们假设A
持有一个 int 成员。然后,代码将如下所示:
class A {
int i;
public:
A(int i1): i(i1) {}
void set(int i1) { i = i1; }
std::shared_ptr<B> ComputeB() {
std::shared_ptr<B> shared_b = my_B.lock();
if (!shared_b){
shared_b = std::make_shared<B>(*this);
my_B = shared_b;
}
return shared_b;
}
A(const A& a): i(a.i) {}
A& operator=(const A& a) { i = a.i; return *this; }
~A() {}
private:
std::weak_ptr<B> my_B;
};
<小时 />保持恒定性
在上面的代码中,无法在const A
对象上调用ComputeB()
。如果我们想支持它,我们需要有一个 const 版本的函数。对于语义问题,我更喜欢将此方法(常量和非常量版本)重命名为getB
。
要提供建议的代码,添加在const A
对象上调用getB
的选项,我们还需要提供一个类B
的示例,该示例能够保存对A
的常量或非常量引用。然后,代码将如下所示:
class A {
int i;
// to prevent code duplication for the const and non-const versions
template<typename AType>
static auto getB(AType&& a) {
std::shared_ptr<B> shared_b = a.my_B.lock();
if (!shared_b){
shared_b = std::make_shared<B>(std::forward<AType>(a));
a.my_B = shared_b;
}
return shared_b;
}
public:
A(int i1): i(i1) {}
void set(int i1) { i = i1; }
std::shared_ptr<B> getB() {
return getB(*this);
}
std::shared_ptr<const B> getB() const {
return getB(*this);
}
A(const A& a): i(a.i) {}
A& operator=(const A& a) { i = a.i; return *this; }
~A() {}
private:
mutable std::weak_ptr<B> my_B;
};
对于 B:
class B {
union Owner {
A* const ptr;
const A* const const_ptr;
Owner(A& a): ptr(&a) {}
Owner(const A& a): const_ptr(&a) {}
} owner;
public:
B(A& a): owner(a) {}
B(const A& a): owner(a) {}
const A& getOwner() const {
return *owner.const_ptr;
}
A& getOwner() {
return *owner.ptr;
}
};
有关使用union
管理同一指针的const和非const版本,请参阅:
- /非常量对象指针的联合
- 通过工会进行常量铸造是未定义的行为吗?
工作示例:http://coliru.stacked-crooked.com/a/f696dfcf85890977
私有创建令牌
上面的代码允许任何人创建可能导致不希望的可能性的B
对象,例如通过获得const A& a
的构造函数创建一个非常量B
对象,导致在调用getOwner()
时从常量转换为非常量。
一个好的解决方案可能是阻止创建B
并仅允许它来自类A
。由于创建是通过make_shared
将B
的构造函数放在B
的private
部分中,并为A
进行friend
声明将无济于事,因此调用new B
make_shared
不是A
。因此,我们采用私有令牌方法,如以下代码所示:
class A {
int i;
// only authorized entities can create B
class B_PrivateCreationToken {};
friend class B;
template<typename AType>
static auto getB(AType&& a) {
std::shared_ptr<B> shared_b = a.my_B.lock();
if (!shared_b){
shared_b = std::make_shared<B> (
std::forward<AType>(a),
B_PrivateCreationToken{} );
a.my_B = shared_b;
}
return shared_b;
}
public:
// public part as in above version...
private:
mutable std::weak_ptr<B> my_B;
};
对于 B:
class B {
union Owner {
A* const ptr;
const A* const const_ptr;
Owner(A& a): ptr(&a) {}
Owner(const A& a): const_ptr(&a) {}
} owner;
public:
B(A& a, A::B_PrivateCreationToken): owner(a) {}
B(const A& a, A::B_PrivateCreationToken): owner(a) {}
// getOwner methods as in above version...
};
代码:http://coliru.stacked-crooked.com/a/f656a3992d666e1e
你可以从 ComputeB() 返回一个 std::shared_ptr,并my_B 变成 std::weak_ptr。像这样:
std::shared_ptr<B> ComputeB() {
if (my_B.expired()) {
auto result = std::make_shared<B>(*this);
my_B = result;
return result;
} else {
return std::shared_ptr<B>(my_B);
}
}
private:
std::weak_ptr<B> my_B;
这个想法是,ComputeB的任何调用方都成为B实例的部分所有者,这意味着只有当它的所有shared_ptrs都被销毁时,它才会被销毁。weak_ptr的目的是指向 B 实例而不拥有它,因此生存期根本不与 A 实例绑定