��鬼螌�� — Sun, 29 May 2011 03:06:00 GMT

转自�Q�http://tech.e800.com.cn/articles/2010/56/1273126029787_1.html

“new”是C++的一个关键字�Q�同时也是操作符。关于new的话题非常多�Q�因为它��实比较复杂�Q�也非常��秘�Q�下面我��把我了解到的与new有关的内容做一个�ȝ��?/p>

　　new的过�E?/p>

　　当我们��用关键字new在堆上动态创��Z��个对象时�Q�它实际上做了三件事�Q�获得一块内存空间、调用构造函数、返回正��的指针。当�Ӟ��如果我们创徏的是��单类型的变量�Q�那么第二步会被省略。假如我们定义了如下一个类A�Q?/p>

　　class A

　　{

　　int i;

　　public:

　　A(int _i) :i(_i*_i) {}

　　void Say() { printf("i=%dn", i); }

　　};

　　//调用new�Q?/p>

　　A* pa = new A(3);

　　那么上述动态创��Z��个对象的�q�程大致相当于以下三句话�Q�只是大致上�Q�：

　　A* pa = (A*)malloc(sizeof(A));

　　pa->A::A(3);

　　return pa;

　　虽然从效果上看，�q�三句话也得��C��一个有效的指向堆上的A对象的指针pa�Q�但区别在于�Q�当malloc��p�|�Ӟ��它不会调用分配内存失败处理程序new_handler�Q�而��用new的话会的。因此我们还是要��可能的使用new�Q�除非有一些特�D�的需求�?/p>

　　new的三�U��Ş�?/p>

　　到目前�ؓ止，本文所提到的new都是指的“new operator”或称�?#8220;new expression”�Q�但事实上在C++中一提到new�Q�至��可能代表以下三�U�含义：new operator、operator new、placement new�?/p>

　　new operator��是我们�q�x��所使用的new�Q�其行�ؓ��是前面所说的三个步骤�Q�我们不能更改它。但具体到某一步骤中的行�ؓ�Q�如果它不满��x��们的具体要求 �Ӟ��我们是有可能更改它的。三个步骤中最后一步只是简单的做一个指针的�c�d��转换�Q�没什么可说的�Q��ƈ且在�~�译出的代码中也�q�不需要这�U��{换，只是��Zؓ的认�? �|�了。但前两步就有些内容了�?/p>

　　new operator的第一步分配内存实际上是通过调用operator new来完成的�Q�这里的new实际上是像加减乘除一��L��操作�W�，因此也是可以重蝲的。operator new默认情况下首先调用分配内存的代码�Q�尝试得��C��D�堆上的�I�间�Q�如果成功就�q�回�Q�如果失败，则�{而去调用一个new_hander�Q�然后��l�重复前�? �q�程。如果我们对�q�个�q�程不满意，��可以重载operator new�Q�来讄��我们希望的行为。例如：

　　class A

　　{

　　public:

　　void* operator new(size_t size)

　　{

　　printf("operator new calledn");

　　return ::operator new(size);

　　}

　　};

　　A* a = new A();

　　�q�里通过::operator new调用了原有的全局的new�Q�实��C��在分配内存之前输��Z��句话。全局的operator new也是可以重蝲的，但这样一来就不能再递归的��用new来分配内存，而只能��用malloc了：

　　void* operator new(size_t size)

　　{

　　printf("global newn");

　　return malloc(size);

　　}

　　相应的，delete也有delete operator和operator delete之分�Q�后者也是可以重载的。�ƈ且，如果重蝲了operator new�Q�就应该也相应的重蝲operator delete�Q�这是良好的�~�程习惯�?/p>

　　new的第三种形�?-placement new是用来实现定位构造的�Q�因此可以实现new operator三步操作中的�W�二步，也就是在取得了一块可以容�U�x��定类型对象的内存后，在这块内存上构造一个对象，�q�有点类��g��前面代码中的 “p->A::A(3);”�q�句话，但这�q�不是一个标准的写法�Q�正��的写法是��用placement new�Q?/p>

　　#include

　　void main()

　　{

　　char s[sizeof(A)];

　　A* p = (A*)s;

　　new(p) A(3); //p->A::A(3);

　　p->Say();

　　}

对头文�g或的引用是必��ȝ��Q�这��h�� 可以使用placement new。这�?#8220;new(p) A(3)”�q�种奇怪的写法便是placement new了，它实��C��在指定内存地址上用指定�c�d��的构造函数来构造一个对象的功能�Q�后面A(3)��是�Ҏ��造函数的昑ּ�调用。这里不隑֏�玎ͼ��q�块指定的地址�? 可以是栈�Q�又可以是堆�Q�placement�Ҏ��不加区分。但是，除非特别必要�Q�不要直接��用placement new �Q�这毕竟不是用来构造对象的正式写法�Q�只不过是new operator的一个步骤而已。��用new operator地编译器会自动生成对placement new的调用的代码�Q�因此也会相应的生成使用delete时调用析构函数的代码。如果是像上面那样在栈上使用了placement new�Q�则必须手工调用析构函数�Q�这也是昑ּ�调用析构函数的唯一情况�Q?/p>

　　p->~A();

　　当我们觉得默认的new operator对内存的��理不能满��我们的需要，而希望自己手工的��理内存�Ӟ��placement new��有用了。STL中的allocator��׃��用了�q�种方式�Q�借助placement new来实现更灉|��有效的内存管理�?/p>

　　处理内存分配异常

　　正如前面所��_��operator new的默认行为是��h��分配内存�Q�如果成功则�q�回此内存地址�Q�如果失败则调用一个new_handler�Q�然后再重复此过�E�。于是，惌��从operator new的执行过�E�中�q�回�Q�则必然需要满��下列条件之一�Q?/p>

　　* 分配内存成功

　　* new_handler中抛出bad_alloc异常

　　* new_handler中调用exit()或类似的函数�Q��ɽE�序�l�束

　　于是�Q�我们可以假��N��认情况下operator new的行为是�q�样的：

　　void* operator new(size_t size)

　　{

　　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;

　　}

　　在默认情况下�Q�new_handler的行为是抛出一个bad_alloc异常�Q�因�? 上述循环只会执行一�ơ。但如果我们不希望��用默认行为，可以自定义一个new_handler�Q��ƈ使用std::set_new_handler函数使其生效。在自定义的new_handler中，我们可以抛出异常�Q�可以结束程序，也可以运行一些代码��得有可能有内存被�I�闲出来�Q�从而下一�ơ分配时也许会成功，也可以通过set_new_handler来安装另一个可能更有效的new_handler。例如：

　　void MyNewHandler()

　　{

　　printf(“New handler called!n”);

　　throw std::bad_alloc();

　　}

　　std::set_new_handler(MyNewHandler);

　　�q�里new_handler�E�序在抛出异�怹�前会输出一句话。应该注意，�? new_handler的代码里应该注意避免再嵌套有对new的调用，因�ؓ如果�q�里调用new再失败的话，可能会再��D��对new_handler的调用，从而导致无限递归调用�?-�q�是我猜的，�q�没有尝试过�?/p>

　　在编�E�时我们应该注意到对new的调用是有可能有异常被抛出的�Q�因此在new的代码周围应该注意保持其事务性，即不能因��用new��p�|抛出异常来导致不正确的程序逻辑或数据结构的出现。例如：

　　class SomeClass

　　{

　　static int count;

　　SomeClass() {}

　　public:

　　static SomeClass* GetNewInstance()

　　{

　　count++;

　　return new SomeClass();

　　}

　　};

静态变量count用于记录此类型生成的实例的个敎ͼ�在上�q�C��码中�Q�如果因new分配内存��p�|而抛出异常，那么其实例个数�ƈ没有增加�Q�但count变量的值却已经多了一个，从而数据结构被破坏。正��的写法是：

　　static SomeClass* GetNewInstance()

　　{

　　SomeClass* p = new SomeClass();

　　count++;

　　return p;

　　}

　　�q�样一来，如果new��p�|则直接抛出异常，count的��g��会增加。类似的�Q�在处理�U�程同步�Ӟ��也要注意�c�M��的问题：

　　void SomeFunc()

　　{

　　lock(someMutex); //加一个锁

　　delete p;

　　p = new SomeClass();

　　unlock(someMutex);

　　}

　　此时�Q�如果new��p�|�Q�unlock��不会被执行�Q�于是不仅造成了一个指向不正确地址的指针p的存在，�q�将��D��someMutex永远不会被解锁。这�U�情冉|��要注意避免的。（参考：C++��言�Q�争取异常安全的代码�Q? <http://dev.yesky.com/490/2087990.shtml>

　　STL的内存分配与traits技�?/p>

　　在《STL原码剖析》一书中详细分析了SGI STL的内存分配器的行为。与直接使用new operator不同的是�Q�SGI STL�q�不依赖C++默认的内存分配方式，而是使用一套自行实现的�Ҏ��。首先SGI STL��可用内存整块的分配�Q��之成为当前进�E�可用的内存�Q�当�E�序中确实需要分配内存时�Q�先从这些已��h��好的大内存块中尝试取得内存，如果��p�|的话再尝�? 整块的分配大内存。这�U�做法有效的避免了大量内存碎片的出现�Q�提高了内存��理效率�?/p>

　　��Z��实现�q�种方式�Q�STL使用了placement new�Q�通过在自��q��理的内存�I�间上��用placement new来构造对象，以达到原有new operator所��h��的功能�?/p>

　　template

　　inline void construct(T1* p, const T2& value)

　　{

　　new(p) T1(value);

　　}

　　此函数接收一个已构造的对象�Q�通过拯��构造的方式在给定的内存地址p上构造一个新�?象，代码中后半截T1(value)便是placement new语法中调用构造函数的写法�Q�如果传入的对象value正是所要求的类型T1�Q�那么这里就相当于调用拷贝构造函数。类似的�Q�因使用�?placement new�Q�编译器不会自动产生调用析构函数的代码，需要手工的实现�Q?/p>

　　template

　　inline void destory(T* pointer)

　　{

　　pointer->~T();

　　}

　　与此同时�Q�STL中还有一个接收两个�P代器的destory版本�Q�可��某容器上指定范围内的对象全部销毁。典型的实现方式��是通过一个��@环来�Ҏ��范围内的对象逐一调用析构函数。如果所传入的对象是非简单类型，�q�样做是必要的，但如果传入的是简单类型，或者根本没有必要调用析构函数的自定义类型（例如只包含数个int成员的结构体�Q�，那么再逐一调用析构函数是没有必要的�Q�也��费了时间。�ؓ 此，STL使用了一�U�称�?#8220;type traits”的技巧，在编译器��判断出所传入的类型是否需要调用析构函敎ͼ�

　　template

　　inline void destory(ForwardIterator first, ForwardIterator last)

　　{

　　__destory(first, last, value_type(first));

　　}

　　其中value_type()用于取出�q�代器所指向的对象的�c�d��信息�Q�于是：

　　template

　　inline void __destory(ForwardIterator first, ForwardIterator last, T*)

　　{

　　typedef typename __type_traits::has_trivial_destructor trivial_destructor;

　　__destory_aux(first, last, trivial_destructor());

　　}

　　//如果需要调用析构函敎ͼ�

　　template

　　inline void __destory_aux(ForwardIterator first, ForwardIterator last, __false_type)

　　{

　　for(; first < last; ++first)

　　destory(&*first); //因first是�P代器�Q?first取出其真正内容，然后再用&取地址

　　}

　　//如果不需要，��׃��么也不做�Q?/p>

　　tempalte

　　inline void __destory_aux(ForwardIterator first, ForwardIterator last, __true_type)

　　{}

　　因上�q�函数全都是inline的，所以多层的函数调用�q�不会对性能造成影响�Q�最�l�编�? 的结果根据具体的�c�d��只是一个for循环或者什么都没有。这里的关键在于__type_traits�q�个模板�c�M��Q�它�Ҏ��不同的T�c? 型定义出不同的has_trivial_destructor的结果，如果T是简单类型，��定义�ؓ__true_type�c�d��Q�否则就定义�? __false_type�c�d��。其中__true_type、__false_type只不�q�是两个没有��M��内容的类�Q�对�E�序的执行结果没有什么意义，�? 在编译器看来它对模板如何特化��具有非帔R��要的指导意义了，正如上面代码所�C�的那样。__type_traits也是特化了的一�p�d��?板类�Q?/p>

　　struct __true_type {};

　　struct __false_type {};

　　template

　　struct __type_traits

　　{

　　public:

　　typedef __false _type has_trivial_destructor;

　　……

　　};

　　template<> //模板特化

　　struct __type_traits //int的特化版�?/p>

　　{

　　public:

　　typedef __true_type has_trivial_destructor;

　　……

　　};

　　…… //其他��单类型的特化版本

　　如果要把一个自定义的类型MyClass也定义�ؓ不调用析构函敎ͼ�只需要相应的定义__type_traits的一个特化版本即可：

　　template<>

　　struct __type_traits

　　{

　　public:

　　typedef __true_type has_trivial_destructor;

　　……

　　};

　模板是比较高�U�的C++�~�程技巧，模板特化、模板偏特化��更是技巧性很强的�? 西，STL中的type_traits充分借助模板特化的功能，实现了在�E�序�~�译期通过�~�译器来军_��为每一处调用��用哪个特化版本，于是在不增加�~�程复杂性的前提下大大提高了�E�序的运行效率。更详细的内容可参考《STL源码剖析》第二、三章中的相兛_��宏V�?/p>

　　带有“[]”的new和delete

　　我们�l�常会通过new来动态创��Z��个数�l�，例如�Q?/p>

　　char* s = new char[100];

　　……

　　delete s;

　　严格的说�Q�上�q�C��码是不正��的�Q�因为我们在分配内存时��用的是new[]�Q�而�ƈ不是��单的new�Q�但释放内存时却用的是delete。正��的写法是��用delete[]�Q?/p>

　　delete[] s;

　　但是�Q�上�q�错误的代码��g��也能�~�译执行�Q��ƈ不会带来什么错误。事实上�Q�new与new[]、delete与delete[]是有区别的，特别是当用来操作复杂�c�d��时。假如针对一个我们自定义的类MyClass使用new[]�Q?/p>

　　MyClass* p = new MyClass[10];

　　上述代码的结果是在堆上分配了10个连�l�的MyClass实例�Q��ƈ且已�l�对它们依次�? 用了构造函敎ͼ�于是我们得到�?0个可用的对象�Q�这一点与Java、C#有区别的�Q�Java、C#中这��L��l�果只是得到�?0个null。换句话��_��使用 �q�种写法时MyClass必须拥有不带参数的构造函敎ͼ�否则会发现编译期错误�Q�因为编译器无法调用有参数的构造函数�?/p>

　　当这��h��造成功后�Q�我们可以再��其释放�Q�释放时使用delete[]�Q?/p>

　　delete[] p;

　　当我们对动态分配的数组调用delete[]�Ӟ��其行为根据所甌��的变量类型会有所�? 同。如果p指向��单类型，如int、char�{�，其结果只不过是这块内存被回收�Q�此时��用delete[]与delete没有区别�Q�但如果p指向的是复杂 �c�d��Q�delete[]会针对动态分配得到的每个对象调用析构函数�Q�然后再释放内存。因此，如果我们对上�q�分配得到的p指针直接使用delete来回�Ӟ�� 虽然�~�译期不报什么错误（因�ؓ�~�译器根本看不出来这个指针p是如何分配的�Q�，但在�q�行�Ӟ��DEBUG情况下）会给��Z��个Debug assertion failed提示�?/p>

　　到这里，我们很容易提��Z��个问�?-delete[]是如何知道要为多��个对象调用析构函数的？要回�{�这个问题，我们可以首先看一看new[]的重载�?/p>

　　class MyClass

　　{

　　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;

　　}

　　// ��d��?/p>

　　MyClass* mc = new MyClass[3];

　　printf("address of mc=%pn", mc);

　　delete[] mc;

　　�q�行此段代码�Q�得到的�l�果为：�Q�VC2005�Q?/p>

　　calling new[] with size=16 address=003A5A58

　　ctor

　　address of mc=003A5A5C

　　dtor

　　虽然�Ҏ��造函数和析构函数的调用结果都在预料之中，但所甌��的内存空间大��以及地址�? 数值却出现了问题。我们的�c�MyClass的大��显然是4个字节，�q�且甌��的数�l�中�?个元素，那么应该一��q��?2个字节才对，但事实上�pȝ��却�ؓ我们�? 请了16字节�Q��ƈ且在operator new[]�q�后我们得到的内存地址是实际申请得到的内存地址值加4的结果。也��是��_��当�ؓ复杂�c�d��动态分配数�l�时�Q�系�l�自动在最�l�得到的内存地址前空��Z�� 4个字节，我们有理��q��信这4个字节的内容与动态分配数�l�的长度有关。通过单步跟踪�Q�很�Ҏ��发现�q?个字节对应的int��gؓ0x00000003�Q�也��是说记录的是我们分配的对象的个数。改变一下分配的个数然后再次观察的结果证实了我的��x��。于是，我们也有理由认�ؓnew[] operator的行为相当于下面的伪代码�Q?/p>

　　template

　　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;

　　}

　上述�C�意性的代码省略了异常处理的部分�Q�只是展�C�当我们对一个复杂类型��用new[] 来动态分配数�l�时其真正的行�ؓ是什么，从中可以看到它分配了比预期多4个字节的内存�q�用它来保存对象的个敎ͼ�然后对于后面每一块空间��?placement new来调用无参构造函敎ͼ��q�也��p��释了��Z��么这�U�情况下�c�d��L��无参构造函敎ͼ�最后再��首地址�q�回。类似的�Q�我们很�Ҏ��写出相应的delete[]的实 ��C��码：

　　template

　　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);

　　}

　　由此可见�Q�在默认情况下operator new[]与operator new的行为是相同的，operator delete[]与operator delete也是�Q�不同的是new operator与new[] operator、delete operator与delete[] operator。当�Ӟ��我们可以�Ҏ��不同的需要来选择重蝲带有和不带有“[]”的operator new和delete�Q�以满��不同的具体需求�?/p>

　　把前面类MyClass的代码稍做修�?-注释掉析构函敎ͼ�然后再来看看�E�序的输出：

　　calling new[] with size=12 address=003A5A58

　　ctor

　　address of mc=003A5A58

　　�q�一�ơ，new[]老老实实的甌��?2个字节的内存�Q��ƈ且申��L��l�果与new[] operator�q�回的结果也是相同的�Q�看来，是否在前面添�?个字节，只取决于�q�个�c�L��没有析构函数�Q�当�Ӟ��q�么说�ƈ不确切，正确的说法是�q�个�c�L��否需要调用构造函敎ͼ�因�ؓ如下两种情况下虽然这个类没声明析构函敎ͼ�但还是多甌��?个字节：一是这个类中拥有需要调用析构函数的成员�Q�二是这个类�l�承自需�? 调用析构函数的类。于是，我们可以递归的定�?#8220;需要调用析构函数的�c?#8221;��Z��下三�U�情况之一�Q?/p>

　　1 昑ּ�的声明了析构函数�?/p>

　　2 拥有需要调用析构函数的�cȝ��成员�?/p>

　　3 �l�承自需要调用析构函数的�cȝ��

　　�c�M��的，动态申��L��单类型的数组�Ӟ��也不会多甌��4个字节。于是在�q�两�U�情况下�Q�释攑ֆ�存时使用delete或delete[]都可以，但�ؓ��L��良好的习惯，我们�q�是应该注意只要是动态分配的数组�Q�释放时��׃��用delete[]�?/p>

　　释放内存时如何知道长�?/p>

　　但这同时又带来了新问题，既然甌��无需调用析构函数的类或简单类型的数组时�ƈ没有记录个数信息�Q�那么operator delete�Q�或更直接的说free()是如何来回收�q�块内存的呢�Q�这��p��研究malloc()�q�回的内存的�l�构了。与new[]�c�M��的是�Q�实际上�? malloc()甌��内存时也多申请了��C��字节的内容，只不�q�这与所甌��的变量的�c�d��没有��M��关系�Q�我们从调用malloc时所传入的参��C��可以理解�q�一 �?-它只接收了要甌��的内存的长度�Q��ƈ不关�p�这块内存用来保存什么类型。下面运行这样一�D�代码做个实验：

　　char *p = 0;

　　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;

　　}

　　我们直接来看VC2005下Release版本的运行结果，DEBUG版因包含了较多的调试信息�Q�这里就不分析了�Q?/p>

　　alloc 0 bytes, address=003A36F0 distance=3815152

　　alloc 4 bytes, address=003A3700 distance=16

　　alloc 8 bytes, address=003A3710 distance=16

　　alloc 12 bytes, address=003A3720 distance=16

　　alloc 16 bytes, address=003A3738 distance=24

　　alloc 20 bytes, address=003A84C0 distance=19848

　　alloc 24 bytes, address=003A84E0 distance=32

　　alloc 28 bytes, address=003A8500 distance=32

　　alloc 32 bytes, address=003A8528 distance=40

　　alloc 36 bytes, address=003A8550 distance=40

　　每一�ơ分配的字节数都比上一�ơ多4�Q�distance��D��录着与上一�ơ分配的差��|��W? 一个差值没有实际意义，中间有一个较大的差��|��可能是这块内存已�l�被分配了，于是也忽略它。结果中最��的差��gؓ16字节�Q�直到我们申�?6字节�Ӟ��q�个�? 值变成了24�Q�后面也有类似的规律�Q�那么我们可以认为申��h��得的内存�l�构是如下这��L��Q?/p>

　　从图中不隄��出，当我们要分配一�D�内存时�Q�所得的内存地址和上一�ơ的��֜�址臛_��要相�?个字节（在DEBUG版中�q�要更多�Q�，那么我们可以猜想�Q�这8个字节中应该记录着与这�D�|��分配的内存有关的信息。观察这8个节内的内容�Q�得到结果如下：

　　图中双��为每�ơ分配所得的地址之前8个字节的内容�?6�q�制表示�Q�从图中�U�线所表示�? 以看刎ͼ��q?个字节中的第一个字节乘�?卛_��到相临两�ơ分配时的距��，�l�过试验一�ơ性分配更大的长度可知�Q�第二个字节也是�q�个意义�Q��ƈ且代表高8位，也就说前面空的这8个字节中的前两个字节记录了一�ơ分配内存的长度信息�Q�后面的六个字节可能与空闲内存链表的信息有关�Q�在��译内存时用来提供必要的信息。这��? 解答了前面提出的问题�Q�原来C/C++在分配内存时已经记录了��够充分的信息用于回收内存�Q�只不过我们�q�_��不关心它�|�了�?/p>

��鬼螌�� 2011-05-29 11:06 发表评论

欧美福利专区,久久国产精品久久w女人spa,国产精品性做久久久久久