求解: 在这几种情况下, 析构函数被调用和不被调用的原因.

#include <iostream>   

using namespace std;   



// --------------------------

// 1. 返回指针的单例实现

// --------------------------

class SingletonA   

{   

public:   

    static SingletonA* GetInstance();

// private: 

    ~SingletonA(); // 有人把这个析构函数定义为private, 不知为什么? 

private:   

    SingletonA(); 

    static SingletonA* m_pInstance;

}; 



SingletonA::SingletonA()   

{     

    cout << "SingletonA: Constructor.\r\n";

} 



SingletonA::~SingletonA()   

{   

    cout << "SingletonA: Destructor.\r\n";

    delete m_pInstance;   

}



SingletonA* SingletonA::m_pInstance = NULL; 



SingletonA* SingletonA::GetInstance()   

{

    if (!m_pInstance)

    {

        m_pInstance = new SingletonA;

    }

    return m_pInstance;   

}



// --------------------------

// 2. 返回引用的单例实现

// --------------------------

class SingletonB

{

public:

    static SingletonB& GetInstance();

private:

    SingletonB();

    SingletonB(const SingletonB&); 

    SingletonB& operator=(const SingletonB&);

    ~SingletonB(); // 不知道为什么要把这个析构函数定义为private?

};



SingletonB::SingletonB()

{

    cout << "SingletonB: Constructor.\r\n";

}



SingletonB::~SingletonB()

{

    cout << "SingletonB: Destructor.\r\n";

}



SingletonB& SingletonB::GetInstance()

{

    static SingletonB theSingleton;

    return theSingleton;

}



// --------------------------

// 3. 随意定义了一个普通类

// --------------------------

class Foo

{

public:

    Foo()

    {

        cout << "Foo: Constructor.\r\n";

    }

// private: 

    ~Foo()      // 这个析构函数如果是private, 下面测试编译叫报错.

    {

        cout << "Foo: Destructor.\r\n";

    }

};



// --------------------------

// 4. 测试

// --------------------------

int main()   

{

    SingletonA* instA = SingletonA::GetInstance();

    SingletonB& instB = SingletonB::GetInstance();

    Foo foo;



    return 0;   

}



// --------------------------

// 5. 控制台输出

// --------------------------

// SingletonA: Constructor.

// SingletonB: Constructor.

// Foo: Constructor.

// Foo: Destructor.

// SingletonB: Destructor.



// --------------------------

// 6. 我的问题

// --------------------------

// (1) 无论SingletonA的析构函数定义成private还是public, 为什么在上面的测试中都不会被调用?

// (2) 无论SingletonB的析构函数定义成private还是public, 为什么在上面的测试中都会被调用? 

// (3) 写的Foo类是想测试通常情况下, 如果析构函数定义成private, 编译就不通过(提示无法调用私有

//     方法), 的确是那样. 那上面SingletonB的(析构函数)即使是private, 为什么也能别调用呢?