如何讓new 操作 不分配內存 只調用構造函數

沒有內存池的時候，你只是用new直接創建了一個對象，但是new的過程分為兩步，首先是分配內存，然后是調用構造函數。
內存池就只是負責內存的分配，有了內存池后，你再去創建對象時候，只需要先從內存池中取出內存，然后再在取出的內存上調用對象的構造函數，產生你需要的對象

 

 

 

如何讓new操作符不分配內存，只調用構造函數 

問題：c++中的new操作符　通常完成兩個工作　分配內存及調用相應的構造出世核函數。
請問：
1）如何讓new操作符不分配內存，只調用構造函數？
2) 這樣的用法有什么用？

解答：（要求new顯式調用構造函數，但不分配內存。）

題目要求不能生成內存 還要調用構造函數 說明這個類里面沒有對內部操作 但可以對外部操作 比如static的數

摘錄：如果我是用new分配對象的，可以顯式調用析構函數嗎？
可能不行。除非你使用定位放置 new.

class Fred
{public:
      Fred()
      {
            cout<<"fuck";
            }
      
      }; 
int main()
{
    
    Fred*f=new((void*)10000)Fred();
    system("pause");   
}   其中這個10000可以是任意數，但不能為0

 

2）
定位放置new（placement new）有很多作用。最簡單的用處就是將對象放置在內存中的特殊位置。這是依靠 new表達式部分的指針參數的位置來完成的：

　

#include <new>        // 必須 #include 這個，才能使用 "placement new"
#include "Fred.h"     // class Fred 的聲明

void someCode()
{
   char memory[sizeof(Fred)];     // Line #1
   void* place = memory;          // Line #2

   Fred* f = new(place) Fred();   // Line #3 (詳見以下的“危險”)
   // The pointers f and place will be equal

   // ...
} 
Line #1 在內存中創建了一個sizeof(Fred)字節大小的數組，足夠放下 Fred 對象。Line #2 創建了一個指向這塊內存的首字節的place指針（有經驗的 C 程序員會注意到這一步是多余的，這兒只是為了使代碼更明顯）。Line #3 本質上只是調用了構造函數 Fred::Fred()。Fred構造函數中的this指針將等於place。因此返回的 f 將等於place。   
Line #3 本質上只是調用了構造函數 Fred::Fred()。

*********************************************************

placement new的作用就是：創建對象但是不分配內存，而是在已有的內存塊上面創建對象。

用於需要反復創建並刪除的對象上，可以降低分配釋放內存的性能消耗。
#include <iostream>
#include <new>

const intchunk = 16;
class Foo
{
public :
int val( ) { return _val; }
Foo( ) { _val = 0; }

private :
int_val;
};

//預分配內存，但沒有Foo對象
char*buf = new char[ sizeof(Foo) * chunk ];

int
main( void )
{
//在buf中創建一個Foo對象
Foo*pb = new (buf) Foo;

//檢查一個對象是否被放在buf中
if ( pb->val() == 0 )
{
cout <<"new expressio worked!" <<endl;
}

//到這里不能再使用pb
delete[] buf;

return 0;

 

 new 和malloc的區別

 

1、new 是c++中的操作符，malloc是c 中的一個函數 

2、new 不止是分配內存，而且會調用類的構造函數，同理delete會調用類的析構函數，而malloc則只分配內存，不會進行初始化類成員的工作，同樣free也不會調用析構函數 

3、內存泄漏對於malloc或者new都可以檢查出來的，區別在於new可以指明是哪個文件的哪一行，而malloc沒有這些信息。 

4、new 和 malloc效率比較                //總之，new的效率要比malloc稍微低一些 
new 有三個字母, malloc有六個字母 
new可以認為是malloc加構造函數的執行。 
new出來的指針是直接帶類型信息的。 
而malloc返回的都是void指針 。 

//在這里，夢夢補充兩點在網上查到的信息： 
1.malloc不會拋出異常，但是new會 
2.你無法重新定義malloc失敗時的默認行為（返回null），但你可以重定義new失敗時的默認行為，比如不讓它拋出異常。 



一：new delete 是運算符，malloc,free是函數 

//到這里，夢夢想，運算符和函數的區別在哪里呢？ 
//查了一下資料，沒有具體的文章去解釋這個問題，倒是論壇上的回答解答了這樣的問題： 
//運算符和函數，要說區別，大概也就是   
//  （1）語法形式上會有區別；   
//  （2）運算符只能重載，不能自定義，函數的名字隨便你起，只要是個標志符就行；但運算符 

//不行，比如，你無法仿照其它語言的符號，自己定義一個乘方運算符“**”。   
//  （3）任何函數都可以重載或者覆蓋，但通常你不能改變運算符作用於內置類型的行為，比如 

//你不能通過重載“operator+”，讓3   +   2產生出6來。 
//（from csdn： http://topic.csdn.net/t/20050901/17/4245022.html #） 

malloc與free是C++/C語言的標准庫函數，new/delete是C++的運算符。它們都可用於申請動態內存和釋放內存。 

對於非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。由於malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加於malloc/free。 
因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。 
我們先看一看malloc/free和new/delete如何實現對象的動態內存管理，見示例。 

class Obj 
{ 
     public : 
          Obj(void){ cout < < “Initialization” << endl; }                      //模擬構造函數的功能 
          ~Obj(void){ cout < < “Destroy” << endl; }                         //模擬析構函數的功能 
         void      Initialize(void){ cout < < “Initialization” << endl; } 
         void      Destroy(void){ cout < < “Destroy” << endl; } 
}; 

void UseMallocFree(void) 
{ 
      Obj    *a = (obj *)malloc(sizeof(obj));    // 申請動態內存 
      a->Initialize();                                         // 初始化 
      //… 
      a->Destroy();                                         // 清除工作 
      free(a);                                                   // 釋放內存 
} 

void UseNewDelete(void) 
{ 
      Obj    *a = new Obj;                              // 申請動態內存並且初始化 
      //… 
      delete a;                                                 // 清除並且釋放內存 
} 

示例用malloc/free和new/delete如何實現對象的動態內存管理： 
類Obj的函數Initialize模擬了構造函數的功能，函數Destroy模擬了析構函數的功能。函數UseMallocFree中，由於malloc/free不能執行構造函數與析構函數，必須調用成員函數Initialize和Destroy來完成初始化與清除工作。函數UseNewDelete則簡單得多。 

所以我 們不要企圖用malloc/free來完成動態對象的內存管理，應該用new/delete 。由於內部數據類型的“對象”沒有構造與析構的過程，對它們而言malloc/free和new/delete是等價的。 
//即對於內置數據類型來說，二者是等價的（但是夢夢認為這個時候還是malloc/free的效率更好一點）。但是對於非內置數據類型，我們只能選擇new/delete 。 

既然new/delete的功能完全覆蓋了malloc/free，為什么C++不把malloc/free淘汰出局呢？ 
這是因為C++程序經常要調用C函數，而C程序只能用malloc/free管理動態內存。 
如果用free釋放“new創建的動態對象”，那么該對象因無法執行析構函數而可能導致程序出錯。如果用delete釋放“malloc申請的動態內存”，理論上講程序不會出錯，但是該程序的可讀性很差。所以new/delete必須配對使用，malloc/free也一樣。 
//即出於兼容性的考慮，C++里保留了C語言的malloc/free函數 

二：new delete在實現上其實調用了malloc,free函數。 

三：new operator除了分配內存，還要調用構造函數。 
        malloc函數只是負責分配內存。 


new 一維數組 
XXX   *arr; 
int   len;     //   動態確定該長度值 

arr   =   new   XXX[len];     //   動態分配，也可以使用   malloc 
... 
delete[]   arr;       //不要忘記釋放 


new 多維數組    //話說這部分資料夢夢昨天找了一天，原來姐姐那里有，汗 

正確的做法是先聲明一個n維數組，每個單元是指向char（DATA_TYPE）的指針，再分別對每個單元分配內存.代碼如下 
char **array=new char*[n]; 
for(int i=0;i<n;i++)  array=new char[m]; 
注意：上面代碼在釋放分配的內存時要特別注意。因為這是“深度內存分配”，所以釋放時，要對每個單元里的指針指向的內存予以釋放。釋放內存代碼如下： 
for(int i=0;i<n;i++)      delete[] array;   
delete[] *array;