作为 class 成员的两个 classes 之间的共享指针
Shared pointer between two classes as class member
我有以下 class 结构:
class Bar {
private:
std::shared_ptr<std::vector<int>> y_;
public:
Bar(std::shared_ptr<std::vector<int>> p):
y_(p)
{}
int getFirstVal() {return y_->at(0);};
};
class Initialiser {
private:
std::vector<int> x_;
Bar bar_;
public:
Initialiser(std::vector<int>& v):
x_(v),
bar_(std::make_shared<std::vector<int>>(x_))
{}
void set_x(std::vector<int> x) {x_ = x;}
void check(std::vector<int> x){
set_x(x);
std::cout << "New value of x= " << bar_.getFirstVal() << std::endl;
}
};
int main(){
std::vector<int> z = {1,2,3};
Initialiser init(z);
std::vector<int> x_new = {4,5,6};
init.check(x_new); // should print 4
}
在 class Initialiser 中,我有一个 int 向量和 class Bar 的一个实例作为私有成员。 Bar 应该使用指向 int 向量的共享指针进行初始化,并且该向量应该在 Initialiser 和 Bar 之间共享。然而,目前,如果 Initialiser 调用 x 的 setter,这不会影响 bar 内的向量。我在 check() 中演示了这一点。为什么 check() 不打印值 4 而仍然是值 1?
Initialiser(std::vector<int>& v):
x_(v),
bar_(std::make_shared<std::vector<int>>(x_))
{}
您创建一个 shared_ptr,它指向一个新向量,即 x_ 的 copy。当然,修改一个不会影响另一个。
直接的解决方案是让 Initialiser 和 Bar 都持有一个 shared_ptr 到向量:
class Initialiser {
private:
std::shared_ptr<std::vector<int>> x_;
Bar bar_;
public:
Initialiser(std::vector<int>& v):
x_(std::make_shared<std::vector<int>>(v)),
bar_(x_)
{}
};
但由于 Bar 对象是 Initialiser 对象的一部分,因此根本不需要智能指针。 Bar 可以简单地保存对向量的引用。这里不存在生命周期管理问题,因为 bar_ 永远不会超过它的容器,容器也不会超过 bar_。
class Bar {
private:
std::vector<int>& y_;
public:
Bar(std::vector<int>& p):
y_(p)
{}
int getFirstVal() {return y_.at(0);};
};
class Initialiser {
private:
std::vector<int> x_;
Bar bar_;
public:
Initialiser(std::vector<int>& v):
x_(v),
bar_(x_)
{}
};
但是请注意,x_ 和 bar_ 的顺序很重要,因此这有点脆弱。成员变量的构造顺序是它们在class定义中出现的顺序,而不是它们在成员初始化列表中的顺序。如果顺序颠倒,程序的行为将是未定义的,因为 bar_ 将在 x_ 之前构造。
这种正确的顺序还可以确保 x_ 在对象销毁期间不会超过 bar_,因为成员的销毁顺序与其初始化相反。
我有以下 class 结构:
class Bar {
private:
std::shared_ptr<std::vector<int>> y_;
public:
Bar(std::shared_ptr<std::vector<int>> p):
y_(p)
{}
int getFirstVal() {return y_->at(0);};
};
class Initialiser {
private:
std::vector<int> x_;
Bar bar_;
public:
Initialiser(std::vector<int>& v):
x_(v),
bar_(std::make_shared<std::vector<int>>(x_))
{}
void set_x(std::vector<int> x) {x_ = x;}
void check(std::vector<int> x){
set_x(x);
std::cout << "New value of x= " << bar_.getFirstVal() << std::endl;
}
};
int main(){
std::vector<int> z = {1,2,3};
Initialiser init(z);
std::vector<int> x_new = {4,5,6};
init.check(x_new); // should print 4
}
在 class Initialiser 中,我有一个 int 向量和 class Bar 的一个实例作为私有成员。 Bar 应该使用指向 int 向量的共享指针进行初始化,并且该向量应该在 Initialiser 和 Bar 之间共享。然而,目前,如果 Initialiser 调用 x 的 setter,这不会影响 bar 内的向量。我在 check() 中演示了这一点。为什么 check() 不打印值 4 而仍然是值 1?
Initialiser(std::vector<int>& v):
x_(v),
bar_(std::make_shared<std::vector<int>>(x_))
{}
您创建一个 shared_ptr,它指向一个新向量,即 x_ 的 copy。当然,修改一个不会影响另一个。
直接的解决方案是让 Initialiser 和 Bar 都持有一个 shared_ptr 到向量:
class Initialiser {
private:
std::shared_ptr<std::vector<int>> x_;
Bar bar_;
public:
Initialiser(std::vector<int>& v):
x_(std::make_shared<std::vector<int>>(v)),
bar_(x_)
{}
};
但由于 Bar 对象是 Initialiser 对象的一部分,因此根本不需要智能指针。 Bar 可以简单地保存对向量的引用。这里不存在生命周期管理问题,因为 bar_ 永远不会超过它的容器,容器也不会超过 bar_。
class Bar {
private:
std::vector<int>& y_;
public:
Bar(std::vector<int>& p):
y_(p)
{}
int getFirstVal() {return y_.at(0);};
};
class Initialiser {
private:
std::vector<int> x_;
Bar bar_;
public:
Initialiser(std::vector<int>& v):
x_(v),
bar_(x_)
{}
};
但是请注意,x_ 和 bar_ 的顺序很重要,因此这有点脆弱。成员变量的构造顺序是它们在class定义中出现的顺序,而不是它们在成员初始化列表中的顺序。如果顺序颠倒,程序的行为将是未定义的,因为 bar_ 将在 x_ 之前构造。
这种正确的顺序还可以确保 x_ 在对象销毁期间不会超过 bar_,因为成员的销毁顺序与其初始化相反。