转载自：http://www.builder.com.cn/2008/0104/696370.shtml
“new”是C++的一个关键字，同时也是操作符。关于new的话题非常多，因为它确实比较复杂，也非常神秘，下面我将把我了解到的与new有关的内容做一个总结。
{
int i;
public:
A(int _i) :i(_i*_i) {}
void Say() { printf("i=%dn", i); }
};
// 调用new：
A* pa = new A(3);
pa->A::A(3);
return pa;
operator就是我们平时所使用的new，其行为就是前面所说的三个步骤，我们不能更改它。但具体到某一步骤中的行为，如果它不满足我们的具体要求
时，我们是有可能更改它的。三个步骤中最后一步只是简单的做一个指针的类型转换，没什么可说的，并且在编译出的代码中也并不需要这种转换，只是人为的认识
罢了。但前两步就有些内容了。
{
public:
void* operator new(size_t size)
{
printf( "operator new calledn");
return ::operator new(size);
}
};
A* a = new A();
{
printf( "global newn");
return malloc(size);
}
void main()
{
char s[sizeof(A)];
A* p = (A*)s;
new(p) A(3); //p->A::A(3);
p->Say();
}
可以使用placement new。这里“new(p) A(3)”这种奇怪的写法便是placement
new了，它实现了在指定内存地址上用指定类型的构造函数来构造一个对象的功能，后面A(3)就是对构造函数的显式调用。这里不难发现，这块指定的地址既
可以是栈，又可以是堆，placement对此不加区分。但是，除非特别必要，不要直接使用placement new
，这毕竟不是用来构造对象的正式写法，只不过是new operator的一个步骤而已。使用new
operator地编译器会自动生成对placement
new的调用的代码，因此也会相应的生成使用delete时调用析构函数的代码。如果是像上面那样在栈上使用了placement
new，则必须手工调用析构函数，这也是显式调用析构函数的唯一情况：
{
void* p = null
while(!(p = malloc(size)))
{
if(null == new_handler)
throw bad_alloc();
try
{
new_handler();
}
catch(bad_alloc e)
{
throw e;
}
catch(…)
{}
}
return p;
}
上述循环只会执行一次。但如果我们不希望使用默认行为，可以自定义一个new_handler，并使用std::set_new_handler函数使其
生效。在自定义的new_handler中，我们可以抛出异常，可以结束程序，也可以运行一些代码使得有可能有内存被空闲出来，从而下一次分配时也许会成
功，也可以通过set_new_handler来安装另一个可能更有效的new_handler。例如：
{
printf(“New handler called!n”);
throw std::bad_alloc();
}
std::set_new_handler(MyNewHandler);
new_handler的代码里应该注意避免再嵌套有对new的调用，因为如果这里调用new再失败的话，可能会再导致对new_handler的调用，
从而导致无限递归调用。——这是我猜的，并没有尝试过。
{
static int count;
SomeClass() {}
public:
static SomeClass* GetNewInstance()
{
count++;
return new SomeClass();
}
};
{
SomeClass* p = new SomeClass();
count++;
return p;
}
{
lock(someMutex); // 加一个锁
delete p;
p = new SomeClass();
unlock(someMutex);
}
STL的内存分配器的行为。与直接使用new operator不同的是，SGI
STL并不依赖C++默认的内存分配方式，而是使用一套自行实现的方案。首先SGI
STL将可用内存整块的分配，使之成为当前进程可用的内存，当程序中确实需要分配内存时，先从这些已请求好的大内存块中尝试取得内存，如果失败的话再尝试
整块的分配大内存。这种做法有效的避免了大量内存碎片的出现，提高了内存管理效率。
inline void construct(T1* p, const T2& value)
{
new(p) T1(value);
}
象，代码中后半截T1(value)便是placement
new语法中调用构造函数的写法，如果传入的对象value正是所要求的类型T1，那么这里就相当于调用拷贝构造函数。类似的，因使用了
placement new，编译器不会自动产生调用析构函数的代码，需要手工的实现：
inline void destory(T* pointer)
{
pointer->~T();
}
围内的对象全部销毁。典型的实现方式就是通过一个循环来对此范围内的对象逐一调用析构函数。如果所传入的对象是非简单类型，这样做是必要的，但如果传入的
是简单类型，或者根本没有必要调用析构函数的自定义类型（例如只包含数个int成员的结构体），那么再逐一调用析构函数是没有必要的，也浪费了时间。为
此，STL使用了一种称为“type traits”的技巧，在编译器就判断出所传入的类型是否需要调用析构函数：
inline void destory(ForwardIterator first, ForwardIterator last)
{
__destory(first, last, value_type(first));
}
inline void __destory(ForwardIterator first, ForwardIterator last, T*)
{
typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
__destory_aux(first, last, trivial_destructor());
}
// 如果需要调用析构函数：
template<class ForwardIterator>
inline void __destory_aux(ForwardIterator first, ForwardIterator last, __false_type)
{
for(; first < last; ++first)
destory(&*first); // 因first是迭代器，*first取出其真正内容，然后再用&取地址
}
//如果不需要，就什么也不做：
tempalte<class ForwardIterator>
inline void __destory_aux(ForwardIterator first, ForwardIterator last, __true_type)
{}
的结果根据具体的类型就只是一个for循环或者什么都没有。这里的关键在于__type_traits<T>这个模板类上，它根据不同的T类
型定义出不同的has_trivial_destructor的结果，如果T是简单类型，就定义为__true_type类型，否则就定义为
__false_type类型。其中__true_type、__false_type只不过是两个没有任何内容的类，对程序的执行结果没有什么意义，但
在编译器看来它对模板如何特化就具有非常重要的指导意义了，正如上面代码所示的那样。__type_traits<T>也是特化了的一系列模
板类：
struct __false_type {};
template <class T>
struct __type_traits
{
public:
typedef __false _type has_trivial_destructor;
……
};
template<> // 模板特化
struct __type_traits<int> //int 的特化版本
{
public:
typedef __true_type has_trivial_destructor;
……
};
…… //其他简单类型的特化版本
struct __type_traits<MyClass>
{
public:
typedef __true_type has_trivial_destructor;
……
};
西，STL中的type_traits充分借助模板特化的功能，实现了在程序编译期通过编译器来决定为每一处调用使用哪个特化版本，于是在不增加编程复杂
性的前提下大大提高了程序的运行效率。更详细的内容可参考《STL源码剖析》第二、三章中的相关内容。
……
delete s;
用了构造函数，于是我们得到了10个可用的对象，这一点与Java、C#有区别的，Java、C#中这样的结果只是得到了10个null。换句话说，使用
这种写法时MyClass必须拥有不带参数的构造函数，否则会发现编译期错误，因为编译器无法调用有参数的构造函数。
同。如果p指向简单类型，如int、char等，其结果只不过是这块内存被回收，此时使用delete[]与delete没有区别，但如果p指向的是复杂
类型，delete[]会针对动态分配得到的每个对象调用析构函数，然后再释放内存。因此，如果我们对上述分配得到的p指针直接使用delete来回收，
虽然编译期不报什么错误（因为编译器根本看不出来这个指针p是如何分配的），但在运行时（DEBUG情况下）会给出一个Debug assertion
failed提示。
{
int a;
public:
MyClass() { printf( "ctorn"); }
~MyClass() { printf( "dtorn"); }
};
void* operator new[](size_t size)
{
void* p = operator new(size);
printf( "calling new[] with size=%d address=%pn", size, p);
return p;
}
// 主函数
MyClass* mc = new MyClass[3];
printf("address of mc=%pn", mc);
delete[] mc;
数值却出现了问题。我们的类MyClass的大小显然是4个字节，并且申请的数组中有3个元素，那么应该一共申请12个字节才对，但事实上系统却为我们申
请了16字节，并且在operator
new[]返后我们得到的内存地址是实际申请得到的内存地址值加4的结果。也就是说，当为复杂类型动态分配数组时，系统自动在最终得到的内存地址前空出了
4个字节，我们有理由相信这4个字节的内容与动态分配数组的长度有关。通过单步跟踪，很容易发现这4个字节对应的int值为0x00000003，也就是
说记录的是我们分配的对象的个数。改变一下分配的个数然后再次观察的结果证实了我的想法。于是，我们也有理由认为new[]
operator的行为相当于下面的伪代码：
T* New[](int count)
{
int size = sizeof(T) * count + 4;
void* p = T::operator new[](size);
*(int*)p = count;
T* pt = (T*)((int)p + 4);
for(int i = 0; i < count; i++)
new(&pt[i]) T();
return pt;
}
来动态分配数组时其真正的行为是什么，从中可以看到它分配了比预期多4个字节的内存并用它来保存对象的个数，然后对于后面每一块空间使用
placement
new来调用无参构造函数，这也就解释了为什么这种情况下类必须有无参构造函数，最后再将首地址返回。类似的，我们很容易写出相应的delete[]的实
现代码：
void Delete[](T* pt)
{
int count = ((int*)pt)[-1];
for(int i = 0; i < count; i++)
pt[i].~T();
void* p = (void*)((int)pt – 4);
T::operator delete[](p);
}
new的行为是相同的，operator delete[]与operator delete也是，不同的是new operator与new[]
operator、delete operator与delete[]
operator。当然，我们可以根据不同的需要来选择重载带有和不带有“[]”的operator new和delete，以满足不同的具体需求。
operator返回的结果也是相同的，看来，是否在前面添加4个字节，只取决于这个类有没有析构函数，当然，这么说并不确切，正确的说法是这个类是否需
要调用构造函数，因为如下两种情况下虽然这个类没声明析构函数，但还是多申请了4个字节：一是这个类中拥有需要调用析构函数的成员，二是这个类继承自需要
调用析构函数的类。于是，我们可以递归的定义“需要调用析构函数的类”为以下三种情况之一：
个数信息，那么operator
delete，或更直接的说free()是如何来回收这块内存的呢？这就要研究malloc()返回的内存的结构了。与new[]类似的是，实际上在
malloc()申请内存时也多申请了数个字节的内容，只不过这与所申请的变量的类型没有任何关系，我们从调用malloc时所传入的参数也可以理解这一
点——它只接收了要申请的内存的长度，并不关系这块内存用来保存什么类型。下面运行这样一段代码做个实验：
for(int i = 0; i < 40; i += 4)
{
char* s = new char[i];
printf( "alloc %2d bytes, address=%p distance=%dn", i, s, s - p);
p = s;
}
一个差值没有实际意义，中间有一个较大的差值，可能是这块内存已经被分配了，于是也忽略它。结果中最小的差值为16字节，直到我们申请16字节时，这个差
值变成了24，后面也有类似的规律，那么我们可以认为申请所得的内存结构是如下这样的：
以看到，这8个字节中的第一个字节乘以8即得到相临两次分配时的距离，经过试验一次性分配更大的长度可知，第二个字节也是这个意义，并且代表高8位，也就
说前面空的这8个字节中的前两个字节记录了一次分配内存的长度信息，后面的六个字节可能与空闲内存链表的信息有关，在翻译内存时用来提供必要的信息。这就
解答了前面提出的问题，原来C/C++在分配内存时已经记录了足够充分的信息用于回收内存，只不过我们平常不关心它罢了。
随机推荐
-
Outlook不能预览和打开Excel文件：
无法打开Outlook邮箱中的Excel附件,确实让人恼火 先不要着急: 1.在开始->运行,输入"regedit" 2.找到路径:HKEY_CURRENT_USER\Sof ...
-
Visual Studio找不到iOS模拟器
Visual Studio找不到iOS模拟器 Visual Studio可以正常连接Mac系统,但是在测试时候,提示以下错误信息:Failed to start iOS Simulator in th ...
-
怎样学法学?——民法学泰斗王利明教授的演讲 z
今晚我讲“怎样学习法律”,但不是讲一般的学习法学的方法,而是主要从法学.法律的特征讲起.(因为)我们学习任何东西,都首先要搞清楚我们的学习对象有什么特征.性质. 我们要了解法律.法学本身的性质,要了解 ...
-
【Todo】抽象渗漏法则 &; 找到理想员工 &; 软件开发成功 12 法则 &; Joel on Software
Joel应该是个软件专家,这是他文章汇总的中文版本: http://local.joelonsoftware.com/wiki/Chinese_%28Simplified%29 其中有几篇值得好好看看 ...
-
【BZOJ3527】【FFT】力
[问题描述]给出n个数qi,给出Fj的定义如下:令Ei=Fi/qi.试求Ei.[输入格式]输入文件force.in包含一个整数n,接下来n行每行输入一个数,第i行表示qi.[输出格式]输出文件forc ...
-
一篇非常经典的springMVC注解实现方式详解
今天公司让搭建个springMVC的注解框架,研究了好半天,网络搜罗了半天,好不容易找到篇,拿来分享下: 原文出处:http://itxxz.com/a/kuangjia/2014/0531/4.ht ...
-
Nginx基础教程PPT
Nginx基础教程PPT By 马冬亮(凝霜 Loki) 一个人的战争(http://blog.csdn.net/MDL13412) pdf版本号下载 watermark/2/text/aHR0cD ...
-
epoll的ET和LT两种模式对比及注意事项
ET模式: 因为ET模式只有从unavailable到available才会触发,所以 1.读事件:需要使用while循环读取完,一般是读到EAGAIN,也可以读到返回值小于缓冲区大小: 如果应用层读 ...
-
easyui combobox 设置滚动条
设置滚动条: 1 panelHeight:200 :设置固定的高度. 2 panelHeight:'auto', panelMaxHeight:200. <input class=" ...
-
Mybatis-java.lang.RuntimeException: org.apache.ibatis.exceptions.PersistenceException: ### Error building SqlSession. ### The error may exist in sqlmap/User.xml ### Cause: org.apache.ibatis.builder.B
mappers(映射器) 使用相对于类路径的资源 如:<mapper resource="sqlmap/User.xml" /> 使用完全限定路径 如:<mapp ...