class independent;
class dependent;
independent o1;
dependent o2;
class dependent
{
private:
dependent(); // Implementation is optional
public:
dependent(const independent& sister)
{
// Initialize stuff
}
}
dependent 类的实例在其整个生命周期中需要 independent 对象才有意义。因此，需要定义一个成员变量引用另一个对象，并且将默认构造函数设为不可访问，并定义自己的构造函数。
class dependent
{
private:
dependent(); // No implementation
public:
dependent(const independent& sister): m_sister(sister)
{
// Initialize stuff
}
const independent& GetSister() const { return m_sister; }
void SetSister(const independent& sister) { m_sister = sister; }
private:
const independent& m_sister;
}
类dependent的实例可能需要一个independent对象来工作，但是不一定非得有一个。可以定义一个成员指针指向另一个对象。
class dependent
{
public:
dependent()
{
// Initialize stuff
}
const independent* GetSister() const { return m_sister; }
void SetSister(const independent* sister) { m_sister = sister; }
private:
const independent* m_sister;
}
现在让我们确保在依赖对象准备好时，independent 对象也已经准备就绪。
您可以使用指针和一个 Init() 函数。
Independent* sister = NULL;
Dependent* brother = NULL;
Init()
{
assert(brother == NULL && sister == NULL);
sister = new independent();
brother = new dependent(sister);
}
您可以在函数中使用静态变量来强制创建的顺序。这样做虽然可行，但如果需要多个类的实例就会变得很麻烦。
independent& GetSister()
{
static independent sister; // Initialized on first use
return sister;
}
dependent& GetBrother()
{
static dependent brother(GetSister()); // Initialized on first use
return brother;
}
最后，最干净的方法可能是尽量摆脱全局变量。相反，你应该使用本地变量（你完全掌控它们的创建顺序）。当然，你需要将它们传递给需要它们的函数，如果有很多这样的函数，那么这会变得繁琐。
但是，当你确定所有需要这些对象的代码时，将其移动到一个对象中可能是有意义的，你最初的两个全局变量只需成为该对象的成员即可。
class Foo
{
public:
Foo(): m_sister(...), m_brother(...)
{
// Initialize stuff
}
// Functions using the objects go here
private:
independent m_sister;
dependent m_brother;
}
嗯，我意识到我的回答有点长了，有点过头了。这是重点：
A依赖于B，那么A在其构造函数中应将B作为参数传递。CreditCard和CreditCardProcessor，情况并不那么糟糕。但是当您开始构建分层软件时，您很快就会开始暴露不需要暴露的状态。举个具体例子，在我工作的某个应用程序中，我将“构造函数中的参数”模式转换为单例，并从应用程序源代码中删除了7kB。这从我们的代码中删除了很多“噪音”。 - Cort Ammonauto这样的新特性也不是为了节省打字而存在的——它们的存在是为了使代码更加通用。像auto这样的特性有好有坏，但都可以减少某种噪音。噪音不是你想要衡量的东西——你想要通过失败概率来衡量。而失败概率并不是信噪比的函数，相反，它是反过来的。 - user541686add(resultFactory, securityCtx, mathCtx, varA, varASecurityCtx, varAAtomicity, varB, varBSecurityCtx, varBAtomicity)的特定性不值得以可读性为代价，相比其全局使用的表亲add(varA, varB)，尤其是对于那些实际需要所有这些非全局上下文的人来说，完整版本是可用的。 - Cort Ammonclass Independent
{
public:
static Independent& getO1()
{
static Independent o1;
return o1;
}
};
class Dependent
{
public:
static Dependent& getO2()
{
Independent::getO1(); // force o1 to exist first
static Dependent o2;
return o2;
}
};
这里使用了静态局部变量初始化规则，确保了无论如何包含 .h 文件，都可以按照顺序进行初始化。
使用静态函数局部变量代替全局变量。文件中的全局变量总是在调用任何函数之前初始化，因此可以使用非内联函数调用来强制全局变量按顺序进行初始化。这样做的附加好处是，您可以自由而安全地添加更多相互依赖的全局变量，而它们就像神奇般地工作一样。
//header
class independent;
independent& o1();
class dependent;
dependent& o2();
//cpp1
independent& o1() {
static independent o;
return o;
}
//cpp2
dependent& o2() {
o1(); //affirm that o1 is constructed first.
static dependento; //now construct o2
return o;
}
int main() {
o1().thingy = -1;
o2().thingy = 3;
}
extern并在一个特定的翻译单元中放置一个定义。模板在这里如何帮助？ - dypextern，但原始注释仍应有效。） - dyp它们的构造顺序无法保证。
消除这种依赖是最好的选择，尽量避免使用全局变量。但如果必须使用，并且希望确保一个在另一个之前运行，最好使用指针和返回指针的函数。
independent * pindependent = null;
dependent * pdependent = null;
independent * getIndependent()
{
if(pindependent == null)
pindependent = new independent(); // fixed the bug pointed to by the Mooing Duck
return pindependent;
}
dependent * getDependent()
{
if(pdependent == null)
{
getIndependent();
pdependent = new dependent(); // fixed the bug pointed to by the Mooing Duck
}
return pdependent;
}
extern independent * getIndependent();
extern dependent * getDependent();
//(!!PSEUDO-CODE!!)
Independent* o1;
Dependent* o2;
void CreateGlobalData();
void DestroyGlobalData();
//...
void CreateGlobalData() {
o1 = new Independent;
o2 = new Dependent(*o1); //This is an assumption that the
//Dependent type takes an Independent parameter.
}
//...
void DestroyGlobalData() {
delete o2; //Always destroy in reverse order!
delete o1;
}