Javascript 关于对象生存期的困惑

背景：我正在尝试创建一个node.js克隆，用于演示和学习

<>我在尝试调用一个从C++中附加到对象的回调时，得到了一个Sebug。我使用

obj->Set（xxx，callback）

为对象赋值。每当出现http请求时，我都会返回到该对象，并使用

obj->get（xxx）

获取该回调并尝试调用它。然而，我在使用指针时遇到了一个错误

代码如下：

#include "HttpWrap.h"
#include <cstdlib>
#include "v8/include/v8.h"
#include "libuv/include/uv.h"

using namespace v8;

HttpWrap::HttpWrap(const Arguments& args)
{
   Local<ObjectTemplate> serverTemplate = ObjectTemplate::New();
   serverTemplate->SetInternalFieldCount(1);
   serverTemplate->Set(String::New("listen"), FunctionTemplate::New(Listen));

   Local<Object> localServer = serverTemplate->NewInstance();
   localServer->SetInternalField(0, External::New(this));

   String::AsciiValue ip_address(args[0]);
   int port = args[1]->Int32Value();

   handle = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
   uv_tcp_init(uv_default_loop(), handle);
   handle->data = this;
   uv_tcp_bind(handle, uv_ip4_addr(*ip_address, port));

   server = Persistent<Object>::New(localServer);
}

Handle<Value> HttpWrap::Listen(const Arguments& args)
{
   puts("HttpWrap::Listen");

   HandleScope scope;

   Local<External> wrap = Local<External>::Cast(args.Holder()->GetInternalField(0));
   HttpWrap* httpWrap = static_cast<HttpWrap*>(wrap->Value());
   httpWrap->server->Set(String::New("onrequest"), args[0]);
   uv_listen((uv_stream_t*) httpWrap->handle, 128, OnConnection);

   return scope.Close(Undefined());
}

void HttpWrap::OnConnection(uv_stream_t* handle, int status)
{
   puts("HttpWrap::OnConnection");
   uv_tcp_t* client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
   uv_tcp_init(uv_default_loop(), client);
   client->data = handle->data;
   uv_accept(handle, (uv_stream_t*) client);
   uv_read_start((uv_stream_t*) client, AllocConnection, OnRead);
}

uv_buf_t HttpWrap::AllocConnection(uv_handle_t* handle, size_t suggested_size)
{
   puts("HttpWrap::AllocConnection");
   return uv_buf_init((char*) malloc(suggested_size), suggested_size);
}

void HttpWrap::OnRead(uv_stream_t* server, ssize_t nread, uv_buf_t buf)
{
   HandleScope scope;
   puts("HttpWrap::OnRead");

   HttpWrap* httpWrap = static_cast<HttpWrap*>(server->data);
   Local<String> callbackSym = String::New("onrequest");
   Local<Value> value = httpWrap->server->Get(callbackSym);

   if (!value->IsFunction())
   {
      puts("Value is not a function");
   }
   else 
   {
      puts("Value is a function");
      Local<Function> callback = Local<Function>::Cast(value);
      Local<Value>* argv = new Local<Value>[1];
      argv[0] = String::New("test");
      puts("Invoking callback");
      callback->Call(Context::GetCurrent()->Global(), 1, argv);
      puts("invoked callback");
   }

   free(buf.base);
   uv_close((uv_handle_t*) server, OnClose);
}

void HttpWrap::OnClose(uv_handle_t* handle)
{
   puts("HttpWrap::OnClose");
} 

#包括“HttpWrap.h”
#包括
#包括“v8/include/v8.h”
#包括“libuv/include/uv.h”
使用名称空间v8；
HttpWrap:：HttpWrap（常量参数和参数）
{
本地serverTemplate=ObjectTemplate:：New（）；
serverTemplate->SetInternalFieldCount（1）；
serverTemplate->Set（String:：New（“listen”）、FunctionTemplate:：New（listen））；
本地localServer=serverTemplate->NewInstance（）；
localServer->SetInternalField（0，External:：New（this））；
字符串：：ascivalue ip_地址（args[0]）；
int port=args[1]->Int32Value（）；
handle=（uv_tcp_t*）malloc（sizeof（uv_tcp_t））；
uv_tcp_init（uv_default_loop（），句柄）；
handle->data=this；
uv_tcp_绑定（句柄，uv_ip4_地址（*ip_地址，端口））；
server=Persistent:：New（localServer）；
}
Handle HttpWrap:：Listen（常量参数和参数）
{
puts（“HttpWrap:：Listen”）；
手镜镜；
Local wrap=Local:：Cast（args.Holder（）->GetInternalField（0））；
HttpWrap*HttpWrap=static_cast（wrap->Value（））；
httpWrap->server->Set（字符串：：New（“onrequest”），args[0]）；
uv_侦听（（uv_流_t*）httpWrap->handle，128，OnConnection）；
返回scope.Close（未定义（））；
}
void HttpWrap:：OnConnection（uv_stream_t*句柄，int状态）
{
puts（“HttpWrap:：OnConnection”）；
uv_tcp_t*客户端=（uv_tcp_t*）malloc（sizeof（uv_tcp_t））；
uv_tcp_init（uv_default_loop（），客户端）；
客户->数据=处理->数据；
uv_接受（句柄，（uv_流_t*）客户端）；
uv_读取开始（（uv_流_t*）客户端，AllocConnection，OnRead）；
}
uv\u buf\u t HttpWrap:：AllocConnection（uv\u句柄\u t*句柄，大小\u t建议大小）
{
puts（“HttpWrap:：AllocConnection”）；
返回uv_buf_init（（char*）malloc（建议大小），建议大小；
}
void HttpWrap:：OnRead（uv_stream_t*服务器、ssize_t nread、uv_buf_t buf）
{
手镜镜；
放置（“HttpWrap:：OnRead”）；
HttpWrap*HttpWrap=static_cast（服务器->数据）；
本地callbackSym=String:：New（“onrequest”）；
本地值=httpWrap->server->Get（callbackSym）；
如果（！value->IsFunction（））
{
看跌期权（“价值不是函数”）；
}
其他的
{
看跌期权（“价值是一个函数”）；
本地回调=本地：：强制转换（值）；
本地*argv=新本地[1]；
argv[0]=String:：New（“测试”）；
puts（“调用回调”）；
回调->调用（Context:：GetCurrent（）->Global（），1，argv）；
看跌期权（“被调用的回调”）；
}
自由（基本单位）；
uv\u关闭（（uv\u handle\u t*）服务器，OnClose）；
}
void HttpWrap:：OnClose（uv\u句柄\u t*句柄）
{
卖出（“HttpWrap:：OnClose”）；
} 

还有

兴趣线是36和65。每当试图调用

回调->调用
时，就会出现SEGFULT

非常感谢您提出的任何想法或良好做法
 不幸的是，在解决这个问题时，我有点狭隘。主要问题是，我在尝试调用回调之前正在处理主上下文。由于上下文被释放，尝试在js空间中调用代码失败。
当发生崩溃并在调试器中检查时，请始终检查可能涉及的指针及其指向的结构，以查看它们是否有效。例如，在GDB中，它可能类似于
print callback
，
print*callback
和
print callback->Call
。