C++的new和delete使用示例詳解

更新時間：2022年12月07日 15:38:58 作者：amjieker

這篇文章主要為大家介紹了C++的new和delete使用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

1. new 和 delete

在C++中，動態(tài)的分配對象和釋放對象我們使用的是new 和 delete那么，new 和 delete 與 c 語言中的 malloc 和 free有什么區(qū)別呢？

我們?yōu)槭裁从忠褂?code>new 和 delete 呢？

首先在C++中，把 new 和 delete 改成了關(guān)鍵字;

new主要做三件事：調(diào)用operator new分配空間、初始化對象、返回指針。
這個時候，就體現(xiàn)出new 和 malloc 的區(qū)別來了，初始化對象，且返回的是一個該類的對象指針。

malloc 只是單純的分配空間，其他的事，一律不管。
若要用malloc體現(xiàn)出new的價值，大抵可以這樣寫一下(我自己的拙見)

template<typename T, typename ...PACK>
T *NEW(PACK... pack) {
  T *tmp = (T *) malloc(sizeof(T)); // 調(diào)用 malloc分配指針
  tmp->T::init(pack...); // 初始化對象
  return tmp; // 返回指針
}

示例類

struct E {
  int x, y;
  void init() {this->x = 0;this->y = 0;}
  void init(int x) {
    init();
    this->x = x;
  }
  void init(int x, int y) {
    init();
    this->x = x;this->y = y;
  }
  void print() {cout << x << " " << y << endl;}
  void add(const E &rsh) {
    this->x += rsh.x;
    this->y += rsh.y;
  }
};

使用

auto tmp1 = NEW<E>(1);
auto tmp2 = NEW<E>(1, 2);
tmp1->print();
tmp2->print();

不夠像的地方：因為類調(diào)用不了自身的構(gòu)造函數(shù)，構(gòu)造函數(shù)的隱式調(diào)用的。所有我采用了一個init函數(shù)來充當我的偽構(gòu)造函數(shù)。（反正分配內(nèi)存時也沒調(diào)用構(gòu)造函數(shù)嘛）

三種 new

拋異常的 new

void *operator new(std::size_t count)
throw(std::bad_alloc);

try {
  const long long N = 10e18;
  auto p = new int8_t[N];
  delete p;
} catch (std::bad_alloc &bad) {
  cout << bad.what() << endl;
}

不拋異常的 new

void *operator new(std::size_t count,
   const std::nothrow_t&) throw();

long long N = 10e18;
auto p = new(std::nothrow) int8_t[N];
assert(p);

palcement new在已有的內(nèi)存上構(gòu)建，不重新分配內(nèi)存

struct E {
  int x, y;
};
auto mall = ::malloc(100);
auto p = new(mall) E{.x = 1, .y = 2};
int32_t *now = static_cast<int32_t *>(mall);
cout << *now << endl;
cout << *++now << endl;
free(mall);

對于第三種，很有意思，相當于把分配內(nèi)存和構(gòu)造分開的設(shè)計

是不是有點眼熟？

啊對對對

就是alloctor的搞法嘛。

有時候構(gòu)造操作是一個比較耗時的操作，這個時候就有用了

struct E {
  int x, y;
  E(int x = 0, int y = 0) : x(x), y(y) {}
  void print() { cout << x << " " << y << endl; }
  void add(const E &rsh) {
    this->x += rsh.x;
    this->y += rsh.y;
  }
};
template<typename T>
T *allocate() { return static_cast<T *>(::malloc(sizeof(T))); }
template<typename T, typename ...PACK>
T *construct(void *ptr, PACK... pack) {
  return new(ptr) T(pack...);
}
signed main() {
  auto t = allocate<E>();
  t = construct<E>(t, 1, 2);
  t->print();
  return 0;
}

2. operator new 和 operator delete

operator new 就是一個運算符了，且我們可以重載這個運算符，使其分配內(nèi)存的方式是我們自定義的分配方式。

比如重載 operator new 來給 new用

struct E {
  E() { cout << "construct" << endl; }
  void *operator new(std::size_t length) {
    cout << "malloc object" << endl;
    return ::malloc(length);
  }
  void *operator new[](std::size_t length) {
    cout << "malloc array" << endl;
    return ::malloc(length);
  }
  void operator delete(void *now) {
    cout << "free object" << endl;
    ::free(now);
  }
  void operator delete[](void *now) {
    cout << "free array" << endl;
    ::free(now);
  }
};
signed main() {
  auto t = new E;
  auto tarray = new E[2];
  delete t;
  delete[] tarray;
}
/* output
malloc object
construct
malloc array
construct
construct
free object
free array
*/

3. 重載 operator new 和 operator delete 有什么用??？有用？

當然，是有用的。在某些時候，可能重載分配方式可能是一個比較好的選擇

眾所周知，若是頻繁的分配一些小對象又釋放的，這樣子的操作是不好的。

雖然操作系統(tǒng)可以幫我們干一些臟活累活，可是，若是根據(jù)性能瓶頸分析，發(fā)現(xiàn)問題出在分配小對象上面，這個時候我們就可以考慮整個內(nèi)存池了。（內(nèi)存分配策略是個大活，我這里的代碼只是簡單示例）

使用內(nèi)存池

struct E {
  int arr[100];
  void *operator new(std::size_t size);
  void operator delete(void *ptr);
};
struct ENode {
  void *node;
  ENode *next;
};
const int MAX_LENGTH = 1024;
ENode *poll = nullptr, *use = nullptr;
auto init = []() -> bool {
  auto now = poll;
  for (int i = 0; i < MAX_LENGTH; i++) {
    if (i == 0) poll = now = new ENode{.node = malloc(sizeof(E)), .next = nullptr};
    else {
      auto pre = now;
      now = new ENode{.node = malloc(sizeof(E)), .next = nullptr};
      pre->next = now;
    }
  }
  return true;
}();
void *E::operator new(std::size_t size) {
  assert(poll != nullptr);
  auto now = poll;
  poll = poll->next;
  now->next = use;
  use = now;
  return now->node;
}
void E::operator delete(void *ptr) {
  assert(use != nullptr);
  auto now = use;
  use = use->next;
  now->next = poll;
  poll = now;
  poll->node = ptr;
}

auto t = std::chrono::high_resolution_clock::now();
E *arr[1024];
for (int i = 0; i < 1000; i++) {
  for (int j = 0; j < 1024; j++) {
    arr[j] = new E;
  }
  for (int j = 0; j < 1024; j++) {
    delete arr[(j + i) % 1024];
  }
}
cout << (std::chrono::high_resolution_clock::now() - t).count() << endl;

不使用內(nèi)存池

struct W {
  int arr[100];
};

auto t = std::chrono::high_resolution_clock::now();
W *arr[1024];
for (int i = 0; i < 1000; i++) {
  for (int j = 0; j < 1024; j++) {
    arr[j] = new W;
  }
  for (int j = 0; j < 1024; j++) {
    delete arr[(j + i) % 1024];
  }
}
cout << (std::chrono::high_resolution_clock::now() - t).count() << endl;