如何在C++；？ 我知道java，但对C++没有多少知识。我正在尝试为代码的main函数中的前3条语句编写一个类 首先，我对C++中对象如何创建有问题。请参阅下面的代码 HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); HandleScope-handle\u范围； 持久上下文=上下文：：New（）； 上下文：：范围上下文\范围（上下文）； 我在C++中声明一个类的变量，该类是在该点创建的类的实例。您不需要像Java中那样使用new关键字。因此，第一条语句将创建HandleScope的实例，该实例将存储在handle_范围中。 现在我不明白第二句话是怎么说的。据我所知，partbefore=将创建一个新的持久对象，该对象可由变量上下文引用。然后Context:：New（）将创建一个新对象并将其存储在Context中？我知道我错了。但我就是不明白它是怎么工作的 我试图为上面写一个C++类。这是我的尝试 class MyClass { private: HandleScope handle_scope; Persistent<Context> context; Context::Scope context_scope; public: MyClass(); }; MyClass::MyClass() { context = Context::New(); context_scope = new Context::Scope(context); } class-MyClass{ 私人： 手柄镜手柄镜； 持续语境； 上下文：：范围上下文\范围； 公众： MyClass（）； }; MyClass:：MyClass（） { context=context:：New（）； 上下文\范围=新上下文：：范围（上下文）； }

我是否正确地完成了初始化

编辑：回复peachykeen（在评论中） 我做了以下实验

我编写了一个测试类，如下所示。 测验 { 公众： 测试（）{

---

cout这将是等效类：

class MyClass {
private:
    HandleScope handle_scope;
    Persistent<Context> context;
    Context::Scope context_scope;

public:
    MyClass(); 
};

MyClass::MyClass()
: context(Context::New()),
  context_scope(context)
{
}

---

正在构造上下文\u作用域并将上下文传递给构造函数。使用构造函数初始值设定项语法在类中获得等效行为，如我的示例所示。

这将是等效类：

class MyClass {
private:
    HandleScope handle_scope;
    Persistent<Context> context;
    Context::Scope context_scope;

public:
    MyClass(); 
};

MyClass::MyClass()
: context(Context::New()),
  context_scope(context)
{
}

---

构造CeExthyScript范围并将上下文传递给构造函数。在我的例子中，使用构造函数初始化语法，在类中获得等价的行为。

，你是正确的，在C++中，对象一被定义就被创建。你不需要使用<代码>新< /Cord>关键字。 但是，与Java不同，可以使用不同的持续时间创建对象。使用

new

在堆上创建一个具有动态存储持续时间的对象：该变量一直存在，直到您显式地

delete

它为止。（并且

new

返回指向所创建对象的指针，以便您可以跟踪它）

如果您只是定义一个对象，就像在第一行和第三行中一样，那么它是使用自动存储持续时间创建的：也就是说，对象存在直到它超出范围

这意味着您可以在函数内创建对象，并保证在您离开函数时会立即销毁这些对象，无论您是如何离开函数。无论您是返回还是引发异常，所有对象都具有自动存储持续时间（创建时不使用

new

）保证被妥善清理

这意味着您应该尽可能避免

新建

。如果必须使用

新建

，则通常应将生成的指针包装到智能指针类中，该类是一个使用自动存储持续时间创建的对象，以便自动销毁。智能指针随后将在新建指针上调用

删除

-自动分配对象，再次确保不会泄漏内存

<>这个区别是一个非常强大的工具，好的C++程序员需要理解它。它是避免内存泄漏的一个关键，或者更一般地说，是各种资源泄漏，并且在某些方面比java垃圾收集器更强大。 例如，我们希望打开一个文件，然后向它写入一些数据。在C++中，我们可以这样做：

Persistent<Context> context = Context::New();

void foo() {
    std::ofstream file("foo.txt");
    doStuff(file); // call a function which does something with the file   
}

由于

文件

是在未使用

新建

的情况下声明的，因为它具有自动存储持续时间，我们可以保证它在超出范围时将调用其析构函数，并且它将被正确清理——也就是说，流将被刷新，文件句柄将被关闭

无论

doStuff

是否会引发异常，这都无关紧要。无论我们如何离开

foo

，

文件

都会被正确地销毁，因此我们不需要像Java中那样，最后尝试

/
尝试
。该类本身是异常安全的，不需要用户付出任何额外的努力。

尝试在java中编写一个类似的代码片段，其中一个保证即使 doStase引发异常，文件也会立即关闭。它将更长，并且需要对用户的部分进行更多的关注。
 
你是对的，在C++中，对象一经定义就被创建。你不需要使用<代码>新的< /Cord>键。字
Persistent<Context> context = Context::New();

但是，与Java不同，可以使用不同的持续时间创建对象。使用
new
在堆上创建一个具有动态存储持续时间的对象：该变量一直存在，直到您显式地
delete
它为止。（并且
new
返回指向所创建对象的指针，以便您可以跟踪它）

如果您只是定义一个对象，就像在第一行和第三行中一样，那么它是使用自动存储持续时间创建的：也就是说，对象存在直到它超出范围

这意味着您可以在函数内创建对象，并保证在您离开函数时会立即销毁这些对象，无论您是如何离开函数。无论您是返回还是引发异常，所有对象都具有自动存储持续时间（创建时不使用
new
）保证被妥善清理

这意味着您应该尽可能避免
新建
。如果必须使用
新建
，通常应将生成的指针包装到智能指针类中，该类是一个使用自动存储持续时间创建的对象，以便自动销毁。智能指针随后将调用
删除
#include <iostream>

class C
{
public:
    C(int)
    {
        std::cout << "C::C(int)" << std::endl;
    }
};

int main()
{
    C c = 1;
}

class MyClass {
private:
    HandleScope handle_scope;
    Persistent<Context> context;
    Context::Scope context_scope;

public:
    MyClass(); 
};

MyClass::MyClass():context(Context::New()),
    context_scope(Context::Scope(context))
{
}