How are objects created in C++? - c++

Question

I know Java but don't have much knowledge of C++. I am trying to write a class for the first 3 statements in main function of the code at https://developers.google.com/v8/get_started.
First I have questions about how objects are created in C++. See the below code.
HandleScope handle_scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
I think in C++ when you declare a variable of a class an instance of the class created at the point. You do not need to use new keyword like in Java. So the first statement would create an instance of HandleScope which will be stored in handle_scope.
Now I do not understand how the second statement would work. With my knowledge the part before = will create a new Persistent object which can be referred by the variable context. Then Context::New() will create a new object and store it in context? Huh, I know I am wrong. But I simply dont get how it would work?
I am trying to write a C++ class for the above. Here is my attempt.
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);
}
Have I done the initialization properly?
EDIT: Reply to peachykeen (in comments)
I did the following experimentation.
I wrote a Test class as below.
Test
{
public:
Test() {
cout << "Test" << endl;
}
};
In the main function I wrote Test test; It outputs "Test" which means an object is created without using new keyword.

Answer 1

You are right, in C++, objects are created as soon as they're defined. You do not need to use the new keyword.
However, unlike in Java, objects can be created with different kinds of duration. Using new creates an object on the heap, with dynamic storage duration: the variable lives until you explicitly delete it. (And new returns a pointer to the created object, so that you can track it)
If you simply define an object, as in your first and third lines, then it is created with automatic storage duration: that is, the object exists until it goes out of scope.
This means that you can create objects inside a function, and be guaranteed that they'll be destroyed as soon as you leave the function -- regardless of how you leave the function. Whether you return, or throw an exception, all objects with automatic storage duration (created without using new) are guaranteed to be properly cleaned up.
This means that you should always avoid new whenever possible. If you have to use new, you should typically wrap the resulting pointer into a smart pointer class, an object created with automatic storage duration, so that it gets destroyed automatically). The smart pointer will then call delete on the new-allocated object automatically, ensuring, again, that you don't leak memory.
This distinction is a very powerful tool, which good C++ programmers need to understand well. It is a key to avoiding memory leaks, or more generally, resource leaks of all kinds, and it is, in some respects, more powerful than Java's garbage collector.
For example, say we wish to open a file, and then write some data to it. In C++, we can do it like this:
void foo() {
std::ofstream file("foo.txt");
doStuff(file); // call a function which does something with the file
}
And because file was declared without using new, because it has automatic storage duration, we are guaranteed that it will have its destructor invoked when it goes out of scope, and it will be properly cleaned up -- that is, the stream will be flushed, and the file handle will be closed.
It doesn't matter if doStuff might throw an exception. No matter how we leave foo, file will be properly destroyed, so we don't need to mess about with try/finally like you would in Java. The class is exception-safe by itself, without requiring any additional effort from the user.
Try writing a similar snippet in Java, one which guarantees that even if doStuff throws an exception, the file will be immediately closed. It'll be much longer, and requires more care on the part of the user.

Answer 2

Persistent<Context> context = Context::New();
create object of type Persistent<Context>, initialized from returned of Context::New, if c-tor is not explicit.
Simple example.
#include <iostream>
class C
{
public:
C(int)
{
std::cout << "C::C(int)" << std::endl;
}
};
int main()
{
C c = 1;
}
your class should be
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))
{
}
if Context::Scope is not pointer.

Answer 3

This would be the equivalent class:
class MyClass {
private:
HandleScope handle_scope;
Persistent<Context> context;
Context::Scope context_scope;
public:
MyClass();
};
MyClass::MyClass()
: context(Context::New()),
context_scope(context)
{
}
When you write a statement like this:
Persistent<Context> context = Context::New();
You are constructing context using the copy constructor. This is different from creating the object and then assigning a new value, although the result might often be equivalent.
Likewise this statement:
Context::Scope context_scope(context);
is constructing context_scope and passing context to the constructor. You get the equivalent behavior in a class using the constructor initializer syntax as in my example.

Answer 4

To create an instance of an object, you need only this: Type name; The newkeyword creates a pointer to an object. Normally, to initialize the object, we use parenthesis: Type name(parameter); Sometimes, when an object supports copying, you can use a function that returns an object and assign it to that object: Type name = Some_function_that_returns_Type(); You can now use name like any other object. If you say Type name = new Type;, you will get a compiler error. The keyword new returns a pointer. It would be correct to say Type * name = new Type;. (Note the *, saying that it is a pointer to a Type class, named name. When I refer to Type it is any object, such as your HandleScope. When I refer to name, it is the new object you are creating. The all of all is this: new is a completely different keyword that refers to pointers. If you are not using pointers, don't use it. Use the basic format Type name(parameter, another_param);.