定位new表达式

• 定义
  定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象

new (place_address) type 
new (place_address) type(initializer-list) 

place_address必须是一个指针，initializer-list是类型的初始化列表
- 调用
定位new表达式实际调用：

T * ptr1 = allocator<T>.allocate(1);//从池对象中申请对象对应的空间， T为对象类型 
new(ptr1)T;//显式调用T类型的构造函数进行初始化

• 使用场景

多用于对象池化处理。最常见的就是内存池技术。

对象池化：将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象所造成的开销。用于充当保存对象的“容器”的对象，被称为“对象池”（Object Pool，或简称Pool

请设计一个类，该类只能在堆上创建对象

将类的构造函数声明为private,但是为了创建该类的对象，则必须提供创建对象和释放对象的接口, 用static函数成员实现

#include <iostream>
using namespace std;
class HeapOnly    
{     
public:         
    static HeapOnly *CreateInstance()      
    {            
        HeapOnly * obj=new HeapOnly;            
        obj->m=2;            
        return obj;        
    }        
    static void DeleteInstance(HeapOnly * obj)      
    {            
        if(obj!=NULL)                
        delete obj;        
    }  
private:        
    HeapOnly(){};        
    ~HeapOnly(){};   
public:      
    int m;  
};    

int main()    
{        
    HeapOnly *obj=HeapOnly::CreateInstance();        
    cout<<obj->m<<endl;        
    HeapOnly::DeleteInstance(obj);        
    return 0;    
} 

请设计一个类，该类只能在栈上创建对象

思路：在堆上创建对象要用到new，为了在类外不能使用new,delete，把new,delete重载为私有

#include <iostream>    
using namespace std;    

class   StackOnly    
{    
public:        
    StackOnly()     
    {           
        cout <<   "constructor."  <<   endl;      
    }        
    ~StackOnly()      
    {          
        cout << "destructor." <<   endl;         
    }    
private:        
    void*   operator   new(size_t size);        
    void*   operator   delete(void * ptr); 
};    

int main() 
{        
    StackOnly s;    
    //StackOnly   *p   =   new   StackOnly; 
    // error     
    return   0;    
} 

请设计一个类，该类只能创建一个对象

思路：类实例化对象时，需要检查是否已经存在同类对象，所以需要静态成员变量；另外还要提供对外的全局访问 方式，所以需要静态方法来创建与销毁该实例对象。

#include <iostream>  
using namespace std;

class singleton 
{ 
public:    
    static singleton* getpsin()    
    {        
        if(psin == NULL)        
        {            
            psin = new singleton();        
        }        
        return psin;    
    }    
    static void relice()    
    {        
        if(psin != NULL)        
        {            
            delete psin;        
        }       
        psin = NULL;    
    } 
private:    
    singleton()    
    {        
        cout<<"+++++"<<endl;    
    }    
    static singleton* psin; 
};

singleton* singleton::psin = NULL; 
int main() 
{    
    singleton* p = singleton::getpsin();    
    return 0;   
}