我想问一下在一个对象和一个成员之间共享参数的“最佳”方法是什么。我试着更好地解释我的问题:我有一个A类需要定义一个特定的参数:
class A
{
public:
A(int);
~A();
private:
int ParameterA;
...
}
此外,我还有第二个B类,其中包含A类对象作为其成员,需要定义另一个参数:
class B
{
public:
B(int);
~B();
private:
A MemberA;
int ParameterB;
...
}
现在我的问题是:如果ParameterA和ParameterB总是相同的,那么使用什么是“最佳”(干净)策略?
我想到了三种可能性
是否还有其他(更好/标准)方法来处理此案件?我应该采用什么方法?
答案 0 :(得分:1)
您可以将参数声明为参考,并将其初始化为参考参数。
class A
{
public:
A(int& val) : ParameterA(val) {}
~A(){}
private:
int& ParameterA;
};
class B
{
public:
B(int val) : ParameterB(val), MemberA(ParameterB) {}
~B(){}
private:
int ParameterB;
A MemberA;
};
答案 1 :(得分:1)
你对两个变量始终保持相同值的危险的直觉是正确的:这至少是代码味道,应该避免。
直接的解决方案是继承:
class A {
public:
A(int a) : parameterA(a) {}
protected:
int parameterA;
};
class B : public A {
public:
B(int a) : A(a) {}
};
当然,这取决于上下文这个解决方案是否可行,但它应该始终是第一个被评估的。
答案 2 :(得分:1)
" best"方式可能取决于A
和B
的使用方式。
在你的选择中,如果可以,我会避免使用1和2,但我认为3可能是一个合理的选择,除非参数真的不是你想暴露的东西。如果您希望将参数设为私有,则可以B
成为A
的朋友。
另一个选择是使参数的所有权远离A
。您可以在类外定义参数(可能在另一个类中)并将引用或指针传递给B
和A
。
更灵活的方法可能是使用共享指针,但在实践中可能不需要这种灵活性。通过使用shared_ptr
,您不会限制您可以对类进行的操作,例如引用,并且它不会将A
或B
的生命周期与外部生命周期联系起来宾语。如果您愿意,可以轻松创建自包含A
:
#include <memory>
using SharedInt = std::shared_ptr<int>;
class A {
public:
A(SharedInt parameter) : parameter_(parameter) {}
private:
SharedInt parameter_;
};
class B {
public:
B(SharedInt parameter) : a_(parameter), parameter_(parameter) {}
private:
A a_;
SharedInt parameter_;
};
int main() {
auto b = B(std::make_shared<int>(3));
auto a = A(std::make_shared<int>(7));
}
但我可能会首先考虑更严格的设计,只在需要时转移到共享指针。