C++ 调用使用包装对象作为Node.js和v8中的参数的函数

我想在node.js中执行如下操作

var a=新的a（）； var b=新的b（）

//onTick应该是一个以B的实例作为参数的函数

a、 onTick=功能（bInst）{ .... }

a、 loop（）

这意味着A有一个属性“onTick”，这是一个在循环中被调用的函数。 注意，A和B被定义为C++包函数，这里定义为

void AClass::Init(Handle<Object> target) {
  Local<FunctionTemplate> tpl = FunctionTemplate::New(New);
  tpl->SetClassName(String::NewSymbol("A"));
  tpl->InstanceTemplate()->SetInternalFieldCount(1);
  tpl->PrototypeTemplate()->Set(String::NewSymbol("tick"),
      FunctionTemplate::New(Tick)->GetFunction());
  tpl->PrototypeTemplate()->Set(String::NewSymbol("loop"),
  FunctionTemplate::New(Loop)->GetFunction());

  constructor = Persistent<Function>::New(tpl->GetFunction());
  constructor->InstanceTemplate()->SetAccessor(String::New("onTick"), GetOnTick, SetOnTick);
  target->Set(String::NewSymbol("A"), constructor);
}

Handle<Value> AClass::New(const v8::Arguments &args) {
  HandleScope scope;
  AClass* acls = new AClass();
  WrappedAClass* wrappedA = new WrappedAClass();
  acls->wrappedAInst_ = wrappedA;
  window->Wrap(args.This());
  return args.This();
}
Handle<Value> AClass::Loop(const Arguments &args) {
  HandleScope scope;
  AClass* acls = ObjectWrap::Unwrap<AClass>(args.This());
  acls->wrappedInst_->loop();
  return scope.Close(Undefined());
}

<> p>因此，我认为我可以进入循环并使用JavaScript函数作为OnTICK函数的唯一方法是首先将JavaScript函数封装成C++函数，然后通过调用StETCKOffic（）来设置该函数。我这样做对吗

我是个不错的程序员，但最近刚开始用C++工作，所以请原谅我明显的错误，最大的错误很可能是：

void SetOnTick(Local<String> property, Local<Function> value, const AccessorInfo& info) {
      AClass* acls = ObjectWrap::Unwrap<AClass>(info.Holder());

      acls->onTick_ = Persistent<Function>::New(value);
      //Here's where I know I'm doing it wrong
      void func(WrappedClassB* wcb) { 
        const unsigned argc = 1;
        Local<Value> argv[argc] = 
          { Local<Value>::New(BClass::Instantiate(wcb)) };
        acls->onTick_->Call(Context::GetCurrent()->Global(), argc, argv);   
      }
      acls->wrappedAInst_->setTickFunc(func);
    }

void SetOnTick（本地属性、本地值、常量附件信息和信息）{
AClass*acls=ObjectWrap:：Unwrap（info.Holder（））；
acls->onTick=持久：：新建（值）；
//在这里我知道我做错了
void func（WrappedClassB*wcb）{
常量无符号argc=1；
本地argv[argc]=
{Local:：New（BClass:：Instantiate（wcb））}；
acls->onTick->Call（Context:：GetCurrent（）->Global（），argc，argv）；
}
acls->wrappedAInst_uu->setTickFunc（func）；
}

---

我仍在试图找出如何创建一个匿名函数，该函数保存外部变量（ACL）的值。我不认为闭包在这里是有效的，关键是这个函数只有一个参数（WrAdDeCubB**WCB），因为它需要被设置为OnTICK函数。

< P>你不必在C++中创建匿名函数。也许你可以这样定义你的

wrappedclass

class WrappedAClass : public InheritedClass{
public:
  void setTickFunc(void (*func)(WrappedBClass*)){
    tickFunc = func;
  }
protected:
  void tickFunc;
  virtual void onTick(WrappedBClass* wbc){
    if(tickFunc){
      tickFunc(wbc);
    }
  }
}

class WrappedAClass : public InheritedClass{
public:
  void setTickFunc(Local<Function> jsFn){
    HandleScope scope;
    jsTickFunc = Persistent<Function>::New(jsTickFunc);
  }
protected:
  Persistent<Function> jsTickFunc;
  virtual void onTick(WrappedBClass* wbc){
    HandleScope scope;
    if(jsTickFunc.IsEmpty())
        return;
    const unsigned argc = 1;
    Local<Value> argv[argc] = 
    { Local<Value>::New(BClass::Instantiate(wcb)) };
    jsTickFunc->Call(Context::GetCurrent()->Global(), argc, argv);  
  }
}

void SetOnTick(Local<String> property, Local<Function> value, const AccessorInfo& info) {
      AClass* acls = ObjectWrap::Unwrap<AClass>(info.Holder());

      acls->onTick_ = Persistent<Function>::New(value);
      //Here's where I know I'm doing it wrong
      void func(WrappedClassB* wcb) { 
        const unsigned argc = 1;
        Local<Value> argv[argc] = 
          { Local<Value>::New(BClass::Instantiate(wcb)) };
        acls->onTick_->Call(Context::GetCurrent()->Global(), argc, argv);   
      }
      acls->wrappedAInst_->setTickFunc(func);
    }

class WrappedAClass : public InheritedClass{
public:
  void setTickFunc(Local<Function> jsFn){
    HandleScope scope;
    jsTickFunc = Persistent<Function>::New(jsTickFunc);
  }
protected:
  Persistent<Function> jsTickFunc;
  virtual void onTick(WrappedBClass* wbc){
    HandleScope scope;
    if(jsTickFunc.IsEmpty())
        return;
    const unsigned argc = 1;
    Local<Value> argv[argc] = 
    { Local<Value>::New(BClass::Instantiate(wcb)) };
    jsTickFunc->Call(Context::GetCurrent()->Global(), argc, argv);  
  }
}

void SetOnTick(Local<String> property, Local<Value> value, const AccessorInfo& info){
  AClass* acls = ObjectWrap::Unwrap<AClass>(info.Holder());
  if (value->IsFunction())
    acls->wrappedAInst_->setTickFunc(Local<Function>::Cast(value));
}