加分 -- 如何在指定的内存区域 new 一个对象？

[everandforever]

周一结贴。
原贴：
http://www.csdn.net/expert/topic/998/998086.xml?temp=.7920191

[skqgd]

有难度...

[finix]

我得方法你试了吗

[Chiun]

gz

[dreamhorse]

你的指定区域是什么意思，是系统已经分配了一块区域，你得到它的地址，然后对象在里面生成，还是直接指定地址，让对象在里面生成？

[dy_paradise]

帮你UP了

[AthlonxpX86]

用汇编。_asm{........}.

[AthlonxpX86]

去学学驱动编程，也许有帮助。

[puppet]

可以使用Placement new

以下摘自more effective C++ Item 8

There are times when you really want to call a constructor directly. Invoking a constructor on an existing object makes no sense, because constructors initialize objects, and an object can only be initialized — given its first value — once. But occasionally you have some raw memory that's already been allocated, and you need to construct an object in the memory you have. A special version of operator new called placement new allows you to do it.

As an example of how placement new might be used, consider this:

class Widget {
public:
Widget(int widgetSize);
...
};

Widget * constructWidgetInBuffer(void *buffer,
int widgetSize)
{
return new (buffer) Widget(widgetSize);
}

This function returns a pointer to a Widget object that's constructed within the buffer passed to the function. Such a function might be useful for applications using shared memory or memory-mapped I/O, because objects in such applications must be placed at specific addresses or in memory allocated by special routines. (For a different example of how placement new can be used, see Item 4.)

Inside constructWidgetInBuffer, the expression being returned is

new (buffer) Widget(widgetSize)

This looks a little strange at first, but it's just a use of the new operator in which an additional argument (buffer) is being specified for the implicit call that the new operator makes to operator new. The operator new thus called must, in addition to the mandatory size_t argument, accept a void* parameter that points to the memory the object being constructed is to occupy. That operator new is placement new, and it looks like this:

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

This is probably simpler than you expected, but this is all placement new needs to do. After all, the purpose of operator new is to find memory for an object and return a pointer to that memory. In the case of placement new, the caller already knows what the pointer to the memory should be, because the caller knows where the object is supposed to be placed. All placement new has to do, then, is return the pointer that's passed into it. (The unused (but mandatory) size_t parameter has no name to keep compilers from complaining about its not being used; see Item 6.) Placement new is part of the standard C++ library (see Item E49). To use placement new, all you have to do is #include <new> (or, if your compilers don't yet support the new-style header names (again, see Item E49), <new.h>).

If we step back from placement new for a moment, we'll see that the relationship between the new operator and operator new, though you want to create an object on the heap, use the new operator. It both allocates memory and calls a constructor for the object. If you only want to allocate memory, call operator new; no constructor will be called. If you want to customize the memory allocation that takes place when heap objects are created, write your own version of operator new and use the new operator; it will automatically invoke your custom version of operator new. If you want to construct an object in memory you've already got a pointer to, use placement new.

(For additional insights into variants of new and delete, see Item E7 and my article on counting objects.)

[puppet]

记得
include <new>
using namespace std;

[xghome]

哪那么麻烦，看着
class A
{
A(){}
~A(){}
void* operator new(void* pBuffer,size_t size) {return pBuffer;}
//重载该对象的new，注意，此处仅为示例，实际时需要计算pBuffer的
//占用情况，不然，一个Buffer就只能创建一个对象了
}

int main(void)
{
char* pBuffer[1024]; //一定要>sizeof(A)
A* a=new A(pBuffer);
....
a->~A(); //这里最重要，通过显式调用析构函数实现对象的delete
}

[xghome]

写错了两点
1、类A中所有函数应该注明public
2、A* a=new (pBuffer) A; //这么写好像比较正确

[xghome]

又写了一个工程测试了一次
#include "stdafx.h"
#include "iostream.h"

class A
{
public:
A() {cout<<"A()"<<endl;}
~A() {cout<<"~A()"<<endl;}
void* operator new (size_t size,void* pBuffer)
{
cout<<"A::new"<<endl;
return pBuffer;
}
void A1() {cout<<"A1()"<<endl;}
};

int main(void)
{
char pBuffer[1024];
A* a=new (pBuffer) A;
a->A1();
a->~A();
return 0;
}

运行结果
A::new
A()
A1()
~A()

这才正确，呵呵，前面写错了点，不好意思
这个程序编译有一个报警
warning C4291: 'void *__cdecl A::operator new(unsigned int,void *)' : no matching operator delete found; memory will not be freed if initialization throws an exception
C:\VCWork\memObjTest\memObjTest.cpp(12) : see declaration of 'new'
说的是没有与异型new对应的delete，不要去管他就是了，因为这种调用法，最重要的就是不能用delete清除对象，否则，内存指针在对象清除时就被清除了，而推出函数时，自动释放pBuffer时，因为这块内存已经标记清除，肯定出错

很多C++的书籍说，显式调用析构函数是一个高级话题，说的就是这种情况