也可以包装 C++ 对象/类使其可以使用 JavaScript 的 new 操作来创建新的实例：

    1. // addon.cc
    2. #include <node.h>
    3. #include "myobject.h"
    5. namespace demo {
    7. using v8::Local;
    8. using v8::Object;
    10. void InitAll(Local<Object> exports) {
    11.   MyObject::Init(exports);
    12. }
    14. NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
    16. }  // namespace demo

    然后，在 myobject.h 中，包装类继承自 node::ObjectWrap：

    1. // myobject.h
    2. #ifndef MYOBJECT_H
    3. #define MYOBJECT_H
    5. #include <node.h>
    6. #include <node_object_wrap.h>
    8. namespace demo {
    10. class MyObject : public node::ObjectWrap {
    11.  public:
    12.   static void Init(v8::Local<v8::Object> exports);
    14.  private:
    15.   explicit MyObject(double value = 0);
    16.   ~MyObject();
    18.   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
    19.   static void PlusOne(const v8::FunctionCallbackInfo<v8::Value>& args);
    21.   double value_;
    22. };
    24. }  // namespace demo
    26. #endif

    在 myobject.cc 中，实现要被开放的各种方法。 下面，通过把 plusOne() 添加到构造函数的原型来开放它：

    1. // myobject.cc
    2. #include "myobject.h"
    4. namespace demo {
    6. using v8::Context;
    7. using v8::Function;
    8. using v8::FunctionCallbackInfo;
    9. using v8::FunctionTemplate;
    10. using v8::Isolate;
    11. using v8::Local;
    12. using v8::Number;
    13. using v8::Object;
    14. using v8::ObjectTemplate;
    15. using v8::String;
    16. using v8::Value;
    18. MyObject::MyObject(double value) : value_(value) {
    19. }
    21. MyObject::~MyObject() {
    22. }
    24. void MyObject::Init(Local<Object> exports) {
    25.   Isolate* isolate = exports->GetIsolate();
    26.   Local<Context> context = isolate->GetCurrentContext();
    28.   Local<ObjectTemplate> addon_data_tpl = ObjectTemplate::New(isolate);
    29.   addon_data_tpl->SetInternalFieldCount(1);  // MyObject::New() 的一个字段。
    30.   Local<Object> addon_data =
    31.       addon_data_tpl->NewInstance(context).ToLocalChecked();
    33.   // 准备构造函数模版
    34.   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New, addon_data);
    35.   tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
    36.   tpl->InstanceTemplate()->SetInternalFieldCount(1);
    38.   // 原型
    39.   NODE_SET_PROTOTYPE_METHOD(tpl, "plusOne", PlusOne);
    41.   Local<Function> constructor = tpl->GetFunction(context).ToLocalChecked();
    42.   addon_data->SetInternalField(0, constructor);
    43.   exports->Set(context, String::NewFromUtf8(
    44.       isolate, "MyObject").ToLocalChecked(),
    45.       constructor).FromJust();
    46. }
    48. void MyObject::New(const FunctionCallbackInfo<Value>& args) {
    49.   Isolate* isolate = args.GetIsolate();
    50.   Local<Context> context = isolate->GetCurrentContext();
    52.   if (args.IsConstructCall()) {
    53.     // 像构造函数一样调用：`new MyObject(...)`
    54.     double value = args[0]->IsUndefined() ?
    55.         0 : args[0]->NumberValue(context).FromMaybe(0);
    56.     MyObject* obj = new MyObject(value);
    57.     obj->Wrap(args.This());
    58.     args.GetReturnValue().Set(args.This());
    59.   } else {
    60.     // 像普通方法 `MyObject(...)` 一样调用，转为构造调用。
    61.     const int argc = 1;
    62.     Local<Value> argv[argc] = { args[0] };
    63.     Local<Function> cons =
    64.         args.Data().As<Object>()->GetInternalField(0).As<Function>();
    65.     Local<Object> result =
    66.         cons->NewInstance(context, argc, argv).ToLocalChecked();
    67.     args.GetReturnValue().Set(result);
    68.   }
    69. }
    71. void MyObject::PlusOne(const FunctionCallbackInfo<Value>& args) {
    72.   Isolate* isolate = args.GetIsolate();
    74.   MyObject* obj = ObjectWrap::Unwrap<MyObject>(args.Holder());
    75.   obj->value_ += 1;
    77.   args.GetReturnValue().Set(Number::New(isolate, obj->value_));
    78. }
    80. }  // namespace demo

    要构建这个例子，myobject.cc 文件必须被添加到 binding.gyp：

    1. {
    2.   "targets": [
    3.     {
    4.       "target_name": "addon",
    5.       "sources": [
    6.         "addon.cc",
    7.         "myobject.cc"
    8.       ]
    9.     }
    10.   ]
    11. }

    测试：

    1. // test.js
    2. const addon = require('./build/Release/addon');
    4. const obj = new addon.MyObject(10);
    5. console.log(obj.plusOne());
    6. // 打印: 11
    7. console.log(obj.plusOne());
    8. // 打印: 12
    9. console.log(obj.plusOne());
    10. // 打印: 13

    当对象被垃圾收集时，包装器对象的析构函数将会运行。 对于析构函数测试，有一些命令行标志可用于强制垃圾收集。 这些标志由底层 V8 JavaScript 引擎提供。 它们随时可能更改或删除。 它们没有由 Node.js 或 V8 记录，并且它们永远不应该在测试之外使用。