class Integral
{
public:
Integral (int = 0); //转换构造函数
private:
int real;
};
Integral A = 1; //调用转换构造函数将1转换为Integral类的对象class Integral
{
public:
Integral (int = 0);
operator int(); //类型转换运算符
private:
int real;
};
Integral A = 1; //调用转换构造函数将1转换为Integral类的对象
int i = A; //调用类型转换运算符函数将A类的对象转换为int类型operator int()
{
return real;
}
class B: public A {};class B
{
operator A();
};此时若有“A a; B b;"，则“a = b;“合法class A
{
A (const B&);
};
实际上，我们不能重定义new和delete表达式的行为，能够被重载的是全局函数operator new和operator delete。
new的执行过程是：首先，调用名为operator new的标准库函数，分配足够大的原始未类型化的内存，以保存指定类型的一个对象；接下来，运行该类型的一个构造函数，用指定初始化式构造对象；最后，返回指向新分配并构造的对象的指针。
delete的执行过程是：首先，对sp指向的对象运行适当的析构函数；然后通过调用名为operator delete的标准函数释放该对象所用内存。
以上的opeartor new与operator delete是可以被重载的。
【例1】
下述代码的输出结果是什么？
#include <iostream>
using namespace std;
class X
{
public:
X() {cout << "constructor" << endl;}
static void* operator new(size_t size)
{
cout << "new" << endl;
return ::operator new(size);
}
static void operator delete(void* point)
{
cout << "delete" << endl;
::operator delete(point);
}
~X() {cout << "destructor" << endl;}
};
int main()
{
X* p = new X();
delete p;
return 0;
}
解答：
new
constructor
destructor
delete
new operator的特点是：
（1）调用operator new分配足够的空间，并调用相关对象的构造函数；
（2）不可以被重载
operator new的特点是：
（1）只分配所要求的空间，并调用相关对象的构造函数；
（2）可以被重载
（3）重载时，返回类型必须声明为void*；
（4）重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为size_t；
（5）重载时，可以带其他参数。
operator new与operator delete和C语言中的malloc与free对应，只负责分配及释放空间。但使用operator new分配的空间必须使用operator delete来释放，而不能使用free，因为他们对内存使用的登记方式不同。反过来也是一样。
#include <iostream>
#include <stdlib.h>
using namespace std;
class Test
{
public:
Test(int n) : n_(n)
{
cout << "Test(int n) : n_(n)" << endl;
}
Test(const Test &other)
{
cout << "Test(const Test& other)" << endl;
}
~Test()
{
cout << "~Test()" << endl;
}
/****************************************************************/
void *operator new(size_t size)
{
cout << "void* operator new(size_t size)" << endl;
void *p = malloc(size);
return p;
}
void operator delete(void *p) //与下面的operator delete函数类似，共存的话优先;
{
//匹配上面的operator new 函数
cout << "void operator delete(void* p)" << endl;
free(p);
}
void operator delete(void *p, size_t size)
{
cout << "void operator delete(void* p, size_t size)" << endl;
free(p);
}
/**********************************************************************/
void *operator new(size_t size, const char *file, long line)
{
cout << " void* operator new(size_t size, const char* file, long line);" << endl;
cout << file << ":" << line << endl;
void *p = malloc(size);
return p;
}
void operator delete(void *p, const char *file, long line)
{
cout << " void operator delete(void* p, const char* file, long line);" << endl;
cout << file << ":" << line << endl;
free(p);
}
void operator delete(void *p, size_t size, const char *file, long line)
{
cout << "void operator delete(void* p, size_t size, const char* file, long line);" << endl;
cout << file << ":" << line << endl;
free(p);
}
/**************************************************************************/
void *operator new(size_t size, void *p)
{
cout << "void* operator new(size_t size, void* p);" << endl;
return p;
}
void operator delete(void *, void *)
{
cout << "void operator delete(void *, void *);" << endl;
}
/**************************************************************************/
int n_;
};
/*************** global **********************************************/
void *operator new(size_t size)
{
cout << "global void* operator new(size_t size)" << endl;
void *p = malloc(size);
return p;
}
void operator delete(void *p)
{
cout << "global void operator delete(void* p)" << endl;
free(p);
}
/**********************************************************************/
void *operator new[](size_t size)
{
cout << "global void* operator new[](size_t size)" << endl;
void *p = malloc(size);
return p;
}
void operator delete[](void *p)
{
cout << "global void operator delete[](void* p)" << endl;
free(p);
}
/***********************************************************************/
int main(void)
{
Test *p1 = new Test(100); // new operator = operator new + 构造函数的调用
delete p1;
char *str1 = new char;
delete str1;
char *str2 = new char[100];
delete[] str2;
char chunk[10];
Test *p2 = new (chunk) Test(200); //operator new(size_t, void *_Where)
// placement new，不分配内存 + 构造函数的调用
cout << p2->n_ << endl;
p2->~Test(); // 显式调用析构函数
//Test* p3 = (Test*)chunk;
Test *p3 = reinterpret_cast<Test *>(chunk);
cout << p3->n_ << endl;
#define new new(__FILE__, __LINE__)
//Test* p4 = new(__FILE__, __LINE__) Test(300);
Test *p4 = new Test(300);
delete p4;
return 0;
}
从输出可以看出几点：
（1）、new operator 是分配内存（调用operator new） + 调用构造函数
（2）、operator new 是只分配内存，不调用构造函数
（3）、placement new 是不分配内存（调用operator new（与2是不同的函数） 返回已分配的内存地址），调用构造函数
（4）、delete 是先调用析构函数，再调用operator delete.
（5）、如果new 的是数组，对应地也需要delete [] 释放
参考：
C++ primer 第四版
版权声明：本文为博主原创文章，未经博主允许不得转载。
C++ Primer 学习笔记_29_操作符重载与转换（4）--转换构造函数和类型转换运算符归纳、operator new 和 operator delete 实现一个简单内存泄漏跟踪器
原文地址：http://blog.csdn.net/keyyuanxin/article/details/47321845
