星罗��布 — Fri, 21 Mar 2008 01:29:00 GMT

[TC++PL] new/delete 操作�W?br>

Cpp Operators of new and delete
1. 动态内存分配与释放(new and delete)
一般说来，一个对象的生命期是由它被创建时所处的区域军_��的。例如，在一对{}�c�d��义的一个对象，在离开�q�个由{}所界定的区域时�Q�该对象��׃��被销毁，在这个区域之外这个对象是不存在的�Q�程序的其他部分不能再引用这个对象了�?/p>

如果希望在离开了创��个对象时所处的区域后，�q�希望这个对象存在�ƈ能��l�引用它�Q�就必须用new操作�W�在自由存储�I�间来分配一个对象。这个过�E�也叫做动态内存分配，也叫堆对象。�Q何由new操作�W�分配的对象都应该用delete操作�W�手动地销毁掉。C++标准�q�没有定义�Q何�Ş式的“垃圾攉��”机制。delete操作�W�只能用于由new�q�回的指针，或者是零。当delete的参数是0�Ӟ��不会产生��M��效果�Q�也��是说这个delete操作�W�对应的函数�Ҏ��׃��会被执行�?/p>

new�Q�delete�Q�既可以分配�Q�释放）单个的对象（当然也包括内建类型）�Q�也可以分配�Q�释放）对象数组。下面是其函数原型：
#include

void* operator new(size_t); // 参数是单个对象的大小

void* operator new[](size_t); // 参数是对象数�l�的�ȝ��大小

void delete(void*);

void delete[](void*);

C++标准中�ƈ没有要求new操作�W�对分配出来的空间进行初始化。下面是使用new分配一个字�W�数�l�的例子�Q?br>char* save_string(const char* p)

{
char* s = new char[strlen(p)+1];

// ...

return s;

}

char* p = save_string(argv[1]);

// ...

delete[] p;

class X { /* ... */ }

X* p = new[10] X;

X* p2 = new X[10];

vector* pv = new vector(5);

在new分配��够的�I�间后，�~�译器会紧接着调用X的缺省构造函数对�I�间�q�行初始化。注意，上述两种形式都是可以的，无论X是内建类型还是自定义用户�c�d��。对于类来说�Q�还可以使用�cȝ��构造函数�Ş式，如上面创建vector�c�d��对象的例子。此外，一个用非数�l��Ş式的new操作�W�创建的对象�Q�不能用数组形式的delete操作�W�来销毁�?/p>

2. 提供自己的内存管理：重蝲new/delete操作�W?br>我们可以为new/delete定义自己的内存管理方式，但是替换全局的new/delete操作�W�的实现是不够好的，原因很明显：有些人可能需要缺省的new/delete操作的一些方面，而另一些�h则可能完全��用另外一�U�版本的实现。所以最好的办法是�ؓ某个特定的类提供它自��q��内存��理方式�?/p>

一个类的operator new()和operator delete()成员函数�Q�隐式地成�ؓ静态成员函数。因此它们没有this指针�Q�也不能修改对象�Q�很好理解，当调用new的时候对象还没有真正创徏呢，当然不能修改对象了！�Q�。当然在重蝲定义的时候，原型�q�是要与前面提到的一致。看下面�q�个例子�Q?/p>

void* Employee::operator new(size_t s)

{
// 分配s字节的内存空��_��q�返回这个空间的地址

�?/p>

void Employee::operator delete(void* p, size_t s)

{
// 假定指针p是指向由Employee::operator new()分配的大��ؓs字节的内存空间�?/p>

// 释放�q�块�I�间以供�pȝ��在以后重用�?/p>

}
��M��一个operator new()的操作符定义�Q�都以一个尺寸��g��为第一个参敎ͼ�且待分配对象的大��隐式给定，其值就作�ؓnew操作�W�函数的�W�一个参数倹{�?/p>

在这里分配空间的具体实现可以是多�U�多��L��Q�可以直接��用malloc/free�Q�缺省的全局new/delete大部分都是用的这�U�）�Q�可以在指定的内存块中分配空��_��下节��要详述�Q�，也可能还有其他的更好的更适合你的应用的方式�?/p>

那么如何重蝲数组形式的new[]/delete[]操作�W�呢�Q�与普通�Ş式一��P��只不�q�delete[]的参数�Ş式稍有不同，如下所�C�：
class Employee {

public:
void* operator new[](size_t);

void operator delete[](void*); // 单参数�Ş式，��了一个size_t参数

void operator delete[](void*,size_t); //两个参数形式也是可以的，但无必要

// ...

};

在编译器的内部实��C��Q�传入new/delete[]的尺寸值可能是数组的大��s加上一个delta。这个delta量是�~�译器的内部实现所定义的某�U�额外开销。�ؓ什么delete操作�W�不需要第二个��寸参数呢？因�ؓ�q�个数组的大��s以及delta量都��q��l?#8220;��C��”了。但是delete[]的两个参数�Ş式的原型也是可以声明的，在调用的时候会把s*sizeof(SomeClass)+delta作�ؓ�W�二个参数��g��入。delta量是与编译器实现相关的，因此对于用户�E�序员来说是不必要知道的。故而这里只提供单参数版本就可以了。（�q�倒是提供了一�U�查看这个delta量的�Ҏ��。根据实际测试，GCC 4.1采用�?个字节的delta量。）

到这里应该注意到�Q�当我们调用operator delete()的时候，只给��Z��指针�Q��ƈ没有�l�出对象大小的参数。那么编译器是怎么知道应该�l�operator delete()提供正确的尺寸值的呢？如果delete参数�c�d��是该对象的��切型别�Q�那么这是一个简单的事情�Q�但是事情�ƈ不是��L��q�样。看下面的例子：

class Manager : public Employee {

int level;

// ...

};
void f()

{
Employee* p = new Manager; // �ȝ��Q�确切型别丢�׃��Q?/p>

delete p;

}
�q�个时候编译器不能得到正确的对象的��寸。这��需要用��L��帮助了：只需要将基类的析构函数声明称��函数卛_��?/p>

3. 在指定位�|�安攑֯��?Placement of Objects)
new操作�W�的�~�省方式是在自由内存�I�间中创建对象。如果希望在指定的地方分配对象，��应该��用这里介�l�的�Ҏ��。看下面的例子：
class X {

public:
X(int);
//...
};
当需要把对象攄��到指定地方的时候，只需要�ؓ分配函数提供一个额外的参数�Q�既指定的某处内存的地址�Q�，然后在��用new的时候提供这��L��一个额外参数即可。看下面的例子：
void* operator new(size_t, void* p) { return p; } // 昄��安放操作�W?/p>

void* buf = reinterpret_cast(0xF00F); // 某个重要的地址

X* p2 = new(buf) X; // 在buf地址处创��Z��个X对象�Q?/p>

// 实际调用函数operator new(sizeof(X),buf)

4. 内存分配��p�|与new_handler
如果new操作�W�不能分配出内存�Q�会发生什么呢�Q�默认情况下�Q�这个分配器会抛��Z��个bad_alloc异常对象。看下面的例子：
void f()

{
try{
for(;;) new char [10000];

}
catch(bad_alloc) {

cerr << "Memory exhausted!\n";

}
}
[疑问�Q�构造一个异常对象也需要内存空��_��既然已经内存耗尽了，那这个内存又从哪里来呢？]
可以自定义内存耗尽时的处理�Ҏ��(new_handler)。当new操作��p�|�Ӟ��首先会调用一个由set_new_handler()指定的函数。我们可以自定义�q�个函数�Q�然后用set_new_handler()来登记。最后当new操作��p�|时可以调用适当的自定义处理�q�程。看下面的例子：
#include // set_new_handler()原型在此头文件中

void out_of_store()

{
cerr << "operator new failed: out of store\n";

throw bad_alloc();

}

set_new_handler(out_of_store);
for(;;) new char[10000];

cout << "done\n";

上述例子中控制流不会到达最后一句输出，也就是说永远不会输出done。而是会输出：
operator new failed: out of store

自定义的new_handler函数的原型如下：
typedef void (*new_handler)();

5. 标准头文�?lt;new>中的原型
下面是标准头文�g中的各种原型声明�Q?br>class bad_alloc : public exception { /* ... */ }

struct nothrow_t { };

extern struct nothrow_t nothrow; // 内存分配器将不会抛出异常

typedef void (*new_handler)();

new_handler set_new_handler(new_handler new_p) throw();

�Q?�Q�普通的内存分配�Q�失败时抛出bad_alloc异常
// 单个对象的分配与释放

void* operator new(size_t) throw(bad_alloc);

void operator delete(void*) throw();

// 对象数组分配与释�?/p>

void* operator new[](size_t) throw(bad_alloc);

void operator delete[](void*) throw();

�Q?�Q�与C方式兼容的内存分配，��p�|时返�?�Q�不抛出异常
// 单个对象分配与释�?/p>

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

void operator delete(void*, const nothrow_t&) throw();

// 对象数组分配与释�?/p>

void* operator new[](size_t, const nothrow_t&) throw();

void operator delete[](void*, const nothrow_t&) throw();

�Q?�Q�从指定�I�间中分配内�?br>// 分配已有�I�间�l�单个对象��?/p>

void* operator new(size_t, void* p) throw() { return p; }

void operator delete(void* p, void*) throw() { } //什么都不做�Q?/p>

// 分配已有�I�间�l�对象数�l��?/p>

void* operator new[](size_t, void* p) throw() {return p;}

void operator delete[](void* p, void*) throw() { } //什么也不做�Q?/p>

在上�q�原型中�Q�抛出空异常的函数都没有办法通过抛出std::bad_alloc发出内存耗尽的信��P��它们在内存分配失败时�q�回0�?/p>

上述原型的��用方法：
class X {

public:

X(){};
X(int n){};

// ...

};
�Q?�Q�可以抛出异常的new/delete操作�W��?br>原型的第一个参敎ͼ�卛_��象（或对象数�l�）的大��，因此在��用时如下所�C�：
X* p = new X;

X* p1 = new X(5);

X* pa = new X[10];

分配对象数组时要注意�Q�只能用�q�种形式�Q�不能用带参数的形式�Q�例如下面的方式是错误的�Q?br>X* pa2 = new[20] X(5);

你想分配一个X数组�Q�每个数�l�元素都�?�q�行初始化，�q�是不能做到的�?/p>

�Q?�Q�不抛出异常而返�?的new/delete操作�W?br>原型的第二个参数要求一个nothrow_t的引用，因此必须�?lt;new>中定义的nothrow全局对象作�ؓnew/delete的参敎ͼ�如下所�C�：

void f()

{
int* p = new int[10000]; // 可能会抛出bad_alloc异常

if(int* q = new(nothrow) int[100000]; {

// 内存分配成功

delete(nothrow)[]q;
}
else {

// 内存分配��p�|

}
}

6. new与异�?br>如果在��用new构造对象时�Q�构造函数抛��Z��异常�Q�结果会怎样�Q�由new分配的内存释放了吗？在通常情况下答案是肯定的；但如果是在指定位�|�上分配对象�I�间�Q�那么答案就不是�q�么��单了。如果这个内存块是由某个�cȝ��new函数分配的，那么��׃��调用其相应的delete函数�Q�如果有的话�Q�，否则不会有释攑ֆ�存的动作发生。这�U�策略很好地处理了标准库中的使用指定内存的new操作�W�，以及提供了成对的分配与释攑և�数的��M��情�Ş�?br>看下面这个例子：
void f(Arena& a, X* buffer)

{
X* p1 = new X;

X* p2 = new X[10];

X* p3 = new(buffer[10]) X;

X* p4 = new(buffer[11]) X[10];

X* p5 = new(a) X;

X* p6 = new(a) X[10];

}
分析�Q�p1和p2��能正确释放其分配的内存�Q�不会造成内存泄漏�Q�这属于一�U�正常情��c��后面的四种情况则比较复杂。对象a如果是采用普通方式分配的内存�Q�那么将能够正确释放其拥有的内存�?/p>

7. malloc/free没用了吗�Q?br>new能够完全替代malloc吗？�l�大部分情况下，�{�案都是肯定的。但是有一�U�情况则非用malloc不可了。根据new的定义，其第一个参数是待分配对象的大小�Q�但在��用时不需要明��地�l�出�q�个倹{��这个值是��q��译器暗中替你完成的。倘若在某�U�情况下�Q�需要在分配一个对象的同时�q�要分配��Z��些额外的�I�间用来��理某些相关的信息。这个额外空间与对象的空间要求连�l�。这个时候new��帮不上了。必��ȝ��malloc把对象和额外�I�间的��d��作为malloc的参数。在分配出来了后�Q�可能需要调用new的放�|��Ş式的调用在该块内存上构造对象�?br>8. 垃圾攉��
当我们�ؓ自己的类提供了自��q��内存��理�Ҏ��Ӟ��有可能会出现内存分配��p�|的情��c��因此我们可能会通过set_new_handler()提供一个更灵��y的内存释放与重用机制。这��׃ؓ实现垃圾攉��提供了一个实现思�\。垃圾收集机制的基本思想是，当一个对象不再被引用�Ӟ��它的内存��可以安全地被新的对象所使用�?br>当比较垃圾收集机制与手工��理方式的代��h��Q�从一下几个方面进行比较：
�q�行旉��Q�内存的使用�Q�可靠性，�U�L��性，�~�程的费用，垃圾攉��器的费用�Q�性能的预期�?/p>

垃圾攉��器必��要处理几个重要的问题：
�Q?�Q�指针的伪装
通常若以非指针的形式来存储一个指针，则把�q�个指针叫做“伪装的指�?#8221;。看下面�q�个例子�Q?br>void f()

{
int* p = new int;

long i1 = reinterpret_cast(p) & 0xFFFF0000;

long i2 = reinterpret_cast(p) & 0x0000FFFF;

p = 0;

// �q�里��׃��存在指向那个整型数的指针了！

p = reinterpret_cast(i1|i2);

// 现在�q�个整型数又被引用了�Q?/p>

}
上例中原本由p持有的指针被伪装成两个整型数i1和i2。垃圾收集器必须��x��q�种伪装的指针�?br>指针伪装�q�有另外一�U��Ş式，卛_��时有指针和非指针成员的union�l�构�Q�也会给垃圾攉��器带来特�D�的问题。看下面的例子：
union U {

int* p;

int i;

};

void f(U u, U u2, U u3)

{
u.p = new int;

u2.i = 99999;

u.i = 8;

// ...

}
通常�q�是不可能知道union中包含的是指针还是整数�?/p>

�Q?�Q�delete函数
通常若��用了自动垃圾攉��Q�那么delete和delete[]函数是不再需要了的。但是delete和delete[]函数除了释放内存的功能外�Q�还会调用析构函数。因此在�q�种情况下，下列调用
delete p;

��只调用析构函数�Q�而内存的复用则向后推�q�，直到内存块被攉��。一�ơ回收多个对象，有助于减��碎片�?/p>

�Q?�Q�析构函�?br>当垃圾收集器准备回收对象�Ӟ��有两�U�办法可选：
[1] ��个对象调用析构函敎ͼ�如果有的话）�Q?/p>

[2] ��这个对象当作原始内存（即不调用析构函数�Q��?/p>

一般垃圾收集器会选择�W�二中方法。这�U�方法gc��成为模拟一�U�无限内存的机制�?br>也有可能设计一�U�gc�Q�它能调用向它注册了的对象的析构函数。这�U�设计的一个重要方面是防止析构函数重复删除一个之前已�l�删除的对象�?/p>

�Q?�Q�内存的��片
处理内存��片的问题上�Q�有两种主要的GC�c�d��Q�拷贝型和保守型。拷贝型GC通过�U�d��对象使得��片�I�间紧凑�Q�而保守型则通过分配方式的改善来减少��片。C++的观点看来，更們֐�于保守型的。因为移动对象将��D��大量的指针和引用�{�失效，所以拷贝型GC在C++中几乎是不可能实现的。此外保守型GC也可以让C++的代码段与C代码�D�共存�?

星罗��布 2008-03-21 09:29 发表评论

国产精品成人aaaaa网站,亚洲性感激情,免费高清在线一区