new、delete在C++中定义为操作符函数，用于动态分配堆上内存。C++编译器对new、delete的底层实现还是调用了malloc()和free()，但做了封装，且C++编译器对new、delete语句在编译时做了一些额外的工作。

1 在堆上new一个对象：先分配memory，再调用构造函数

有Complex类：

class complex {
private:
 double re, im;
public:
 complex(double r = 0, double i = 0) :re(r), im(i) {
 }
 complex& operator += (const complex&);
 double real() const {
 return re;
 }
 double imag() const {
 return im;
 }
 friend complex& __doapl(complex*, const complex&);
};

在堆上new一个对象：

Complex* pc = new Complex(1,2);

编译器转化为：

Complex *pc;
 void* mem = operator new(sizeof(Complex)); // ① 分配内存，内部调用malloc(n)
 pc = static_cast<Complex*>(mem); // ② 转型
 pc->Complex::Copmlex(1,2); // ③ 调用构造函数

2 delete ：先调用析构函数，在释放memory

Complex* pc = new Complex(1,2);
...
delete pc;

编译器转化为：

Complex::~Complex(pc); // ① 调用析构函数
operator delete(pc); // ② 释放内存，内部调用free(pc)

附complex类代码：

//complex.h
#ifndef __MYCOMPLEX__
#define __MYCOMPLEX__
#include<iostream>
using namespace std;
class complex; 
complex&
 __doapl (complex* ths, const complex& r);
complex&
 __doami (complex* ths, const complex& r);
complex&
 __doaml (complex* ths, const complex& r);
class complex
{
public:
 complex (double r = 0, double i = 0): re (r), im (i) { }
 complex& operator += (const complex&);
 complex& operator -= (const complex&);
 complex& operator *= (const complex&);
 complex& operator /= (const complex&);
 double real () const { return re; }
 double imag () const { return im; }
private:
 double re, im;
 friend complex& __doapl (complex *, const complex&);
 friend complex& __doami (complex *, const complex&);
 friend complex& __doaml (complex *, const complex&);
 //friend ostream& operator << (ostream& os, const complex& x);
};
inline complex&
__doapl (complex* ths, const complex& r)
{
 ths->re += r.re;
 ths->im += r.im;
 return *ths;
}
 
inline complex&
complex::operator += (const complex& r)
{
 return __doapl (this, r);
}
inline complex&
__doami (complex* ths, const complex& r)
{
 ths->re -= r.re;
 ths->im -= r.im;
 return *ths;
}
 
inline complex&
complex::operator -= (const complex& r)
{
 return __doami (this, r);
}
 
inline complex&
__doaml (complex* ths, const complex& r)
{
 double f = ths->re * r.re - ths->im * r.im;
 ths->im = ths->re * r.im + ths->im * r.re;
 ths->re = f;
 return *ths;
}
inline complex&
complex::operator *= (const complex& r)
{
 return __doaml (this, r);
}
 
inline double
imag (const complex& x)
{
 return x.imag ();
}
inline double
real (const complex& x)
{
 return x.real ();
}
inline complex
operator + (const complex& x, const complex& y)
{
 return complex (real (x) + real (y), imag (x) + imag (y));
}
inline complex
operator + (const complex& x, double y)
{
 return complex (real (x) + y, imag (x));
}
inline complex
operator + (double x, const complex& y)
{
 return complex (x + real (y), imag (y));
}
inline complex
operator - (const complex& x, const complex& y)
{
 return complex (real (x) - real (y), imag (x) - imag (y));
}
inline complex
operator - (const complex& x, double y)
{
 return complex (real (x) - y, imag (x));
}
inline complex
operator - (double x, const complex& y)
{
 return complex (x - real (y), - imag (y));
}
inline complex
operator * (const complex& x, const complex& y)
{
 return complex (real (x) * real (y) - imag (x) * imag (y),
 real (x) * imag (y) + imag (x) * real (y));
}
inline complex
operator * (const complex& x, double y)
{
 return complex (real (x) * y, imag (x) * y);
}
inline complex
operator * (double x, const complex& y)
{
 return complex (x * real (y), x * imag (y));
}
complex
operator / (const complex& x, double y)
{
 return complex (real (x) / y, imag (x) / y);
}
inline complex
operator + (const complex& x)
{
 return x;
}
inline complex
operator - (const complex& x)
{
 return complex (-real (x), -imag (x));
}
inline bool
operator == (const complex& x, const complex& y)
{
 return real (x) == real (y) && imag (x) == imag (y);
}
inline bool
operator == (const complex& x, double y)
{
 return real (x) == y && imag (x) == 0;
}
inline bool
operator == (double x, const complex& y)
{
 return x == real (y) && imag (y) == 0;
}
inline bool
operator != (const complex& x, const complex& y)
{
 return real (x) != real (y) || imag (x) != imag (y);
}
inline bool
operator != (const complex& x, double y)
{
 return real (x) != y || imag (x) != 0;
}
inline bool
operator != (double x, const complex& y)
{
 return x != real (y) || imag (y) != 0;
}
#include <cmath>
inline complex
polar (double r, double t)
{
 return complex (r * cos (t), r * sin (t));
}
inline complex
conj (const complex& x) 
{
 return complex (real (x), -imag (x));
}
inline double
norm (const complex& x)
{
 return real (x) * real (x) + imag (x) * imag (x);
}
ostream& operator << (ostream& os, const complex& x)
{
 return os << '(' << real (x) << ',' << imag (x) << ')';
}
#endif //__MYCOMPLEX__
//complex.cpp
#include <iostream>
#include "complex.h"
using namespace std;
int main()
{
 complex c1(2, 1);
 complex c2(4, 0);
 cout << c1 << endl;
 cout << c2 << endl;
 
 cout << c1+c2 << endl;
 cout << c1-c2 << endl;
 cout << c1*c2 << endl;
 cout << c1 / 2 << endl;
 
 cout << conj(c1) << endl;
 cout << norm(c1) << endl;
 cout << polar(10,4) << endl;
 
 cout << (c1 += c2) << endl;
 
 cout << (c1 == c2) << endl;
 cout << (c1 != c2) << endl;
 cout << +c2 << endl;
 cout << -c2 << endl;
 
 cout << (c2 - 2) << endl;
 cout << (5 + c2) << endl;
 system("pause");
 return 0;
}

－End－