普通对象，类成员对象，静态类成员对象的区别及单例应用

目录

1.普通对象和普通指针

2.类成员对象和类成员指针

3.静态类成员对象和静态类成员指针

4.静态(static)类成员对象和静态类成员指针的应用

---

1.普通对象和普通指针

class A{
private:
    string _name;
public:
     A():_name("Jay"){std::cout<<"A()"<<std::endl;}
     A(string name):_name(name){std::cout<<"A():"<<_name<<std::endl;}
    ~A(){std::cout<<"~A():"<<_name<<std::endl;}
 };

 //普通对象
int main()
{
    //普通类对象(栈),自动释放
    A a("A::a");      
    //普通类指针(堆),自己释放内存
    A *pa=new A("A::pa");
    delete pa;
    return 0;
}

//创建a对象
A():A::a
//创建pa指针
A():A::pa
//手动释放pa指针
~A():A::pa
//自动释放a对象
~A():A::a

2.类成员对象和类成员指针

 

class A{
private:
    string _name;
public:
     A():_name("Jay"){std::cout<<"A()"<<std::endl;}
     A(string name):_name(name){std::cout<<"A():"<<_name<<std::endl;}
    ~A(){std::cout<<"~A():"<<_name<<std::endl;}
 };

class B{
private:
    A a;            
    A *pa;
public:
     B():a("a")
     {
         pa=new A("pa");
         std::cout<<"B()"<<std::endl;
    }
    ~B()
    {
        if(pa!=nullptr)
            delete pa;
        std::cout<<"~B()"<<std::endl;
    }
 };

 //普通对象
int main()
{
    //类成员对象b::a(栈)，自动释放
     //类成员指针b::pa(堆)，手动释放
    B b;
    //指针内嵌套类成员对象pb::a(delete pb时自动释放)
    //指针内嵌套类成员指针pb::pa(delete pb时手动释放)
    B *pb=new B();    
    delete pb;
    return 0;
}

//创建b对象
A():a
A():pa
B()
//创建pb指针
A():a
A():pa
B()
//手动释放pb指针
~A():pa    //手动释放pa类成员指针
~B()
~A():a    //自动释放a类成员对象
//自动释放b对象
~A():pa
~B()
~A():a

3.静态类成员对象和静态类成员指针

class A{
private:
    string _name;
public:
     A():_name("Jay"){std::cout<<"A()"<<std::endl;}
     A(string name):_name(name){std::cout<<"A():"<<_name<<std::endl;}
    ~A(){std::cout<<"~A():"<<_name<<std::endl;}
 };

class B{
private:
    static A sa;
    static A *spa;
public:
     B(){std::cout<<"B()"<<std::endl;}
    ~B(){std::cout<<"~B()"<<std::endl;}
    static void destroy_static()
    {
        if(spa!=nullptr)
            delete spa;
    }
 };

A B::sa("sa");
A *B::spa=new A("spa");

int main(void)
{
     //静态类成员对象b::sa(静态区),类创建时申请内存，程序结束时自动释放
    //静态类成员指针b::psa(指针静态区，指向对象堆)，手动释放
    B b;
     //静态类成员对象b::sa(静态区),类创建时申请内存，程序结束时自动释放
    //静态类成员指针b::psa(指针静态区，指向对象堆)，手动释放
    //(且只能在所有对象销毁后释放一次)
    B *pb=new B();    
    delete pb;
	
    B::destroy_static();
    return 0;
}

//创建sa静态类成员对象
A():sa
//创建spa静态类成员指针
A():spa
//创建b对象
B()
//创建pb对象
B()
//手动释放pb对象
~B()
//手动释放spa对象(自动释放的永远在手动释放的后边)
~A():spa
//自动释放b对象
~B()
//自动释放sa静态类成员对象
~A():sa

4.静态(static)类成员对象和静态类成员指针的应用

class Singleton
{
private:
	class AuxiliaryRelease
	{
	public:
		AuxiliaryRelease(){cout << "AuxiliaryRelease()" << endl;}
		~AuxiliaryRelease()
		{
			if(_instance)
			{
				delete _instance;
				cout << "~AuxiliaryRelease()" << endl;
			}
		}
	};
public:
	static Singleton * getInstance()
	{
		if(_instance == nullptr)
			_instance = new Singleton;
		return _instance;
	}
 
private:
	Singleton(){	cout << "Singleton()" << endl;}
	~Singleton(){	cout << "~Singleton()" << endl;}
 
private:
	static Singleton * _instance;
	static AuxiliaryRelease _auxiliary_release;
};
 
Singleton * Singleton::_instance = nullptr;      
//类的静态对象会自动析构(前提是对象，而且是静态) 
Singleton::AuxiliaryRelease Singleton::_auxiliary_release;    

int main(void)
{
    Singleton *p1 = Singleton::getInstance();
	Singleton *p2 = Singleton::getInstance();
	return 0;
}

//静态类成员对象（类创建时）
AuxiliaryRelease()
//静态类成员指针定义
Singleton()
//手动释放静态类成员指针
~Singleton()
//自动释放静态类成员对象
~AuxiliaryRelease()