Ways to instantiate an object and declare constructors

Question

In C++ there are several ways to create a constructor and instantiate an object. But there are so many ways I’m confused by the difference of each.

Assuming I have the following class:

using namespace std;
class Carro
{
    private:
        string modelo;
        string marca;
    public:
        Carro(){}
        Carro(string x, string y) { modelo = x; marca = y;}
}

What would be the difference between the following ways of instantiating the object?

Carro carro = new Carro;

Carro carro;

Carro carro();

Carro carro("Astra", "Chevrolet");

Carro *carro = new Carro;    // Usando ponteiro

Carro *carro = new Carro();  // Usando ponteiro

I would also like to know how the : when declaring a constructor, for example:

Carro(string x, string y) : modelo(x), marca(y) {}

Answer 1

Carro carro = new Carro;

Is not possible.

Carro carro;

Is declaring the type variable Carro but nothing is being assigned to this variable. It is stored in stack.

Carro carro();

Is declaring a function that returns a type Carro. It doesn’t make much sense in this context.

Carro carro("Astra", "Chevrolet");

You are calling a constructor of the class that receives the specified parameters.

Carro *carro = new Carro;

Changes the initialization form. In most cases it makes no difference. There are cases where initialization may occur by default or by value. In this example the result will be the same but depending on how the class is declared, you can initialize differently. I don’t know all the details about this.

Carro *carro = new Carro();

Is allocating in the heap, so you need to create a new memory allocation and the address of this allocation will obviously be assigned to a pointer and not directly to the type.

I put in the Github for future reference.

Understand about stack and heap.

Learn more about builders.

See about overload and method signature.

Allocation and pointer information.

More information why use pointers.

How to decide whether to use pointer.

Similar question with a few more details.

The last question is already another matter and should be another question but I think you can understand in already asked question.

Answer 2

There are some minor nuances left to explain, so I leave here some comments.

For your example

using namespace std;
class Carro
{
    private:
        string modelo;
        string marca;
    public:
        Carro(){}
        Carro(string x, string y) { modelo = x; marca = y;}
}

• Car car = new car;

  • This statement is invalid/syntax is not valid in C++

• Car;

  • Declares a Car type variable in the local scope (Scope), usually in the stack, which will be automatically destroyed when the scope (Scope) ends.

• Car();

  • Declares not a variable but yes a function no arguments, which returns an object of type Car. This is the reason why you get the following error message: error: request for member 'getModelo' in 'carro', which is of non-class type 'Carro(). It’s easy now to understand why the mistake.

• Car car("Astra", "Chevrolet");

  • Declares a Car type variable in the local scope (Scope), usually in the stack, which will be automatically destroyed when the scope (Scope) ends. Unlike the second example, the default constructor will not be executed here, but the constructor that takes two arguments.

• Car *car = new car; // Using pointer

  • Default constructor call (default startup)

• Car *car = new car(); // Using pointer

  • Default constructor call (value initialization)

In the last two examples the difference is related to the initialization of the members of the class, but for your example in particular, there is no practical difference. Instructions allocate a memory space by calling the operator new() and implicitly call the constructor Carro::Carro(), with the sharpener this pointing to a space in that memory (returned by new()). This address is then stored in the pointer carro (stack). Since the allocated memory is not automatically released when the scope ends, it is necessary to perform the memory management manually through the instruction delete.

If you want to read more about the difference between

Carro *carro = new Carro;    // Usando ponteiro
Carro *carro = new Carro();  // Usando ponteiro

You can read the language standard itself:

To zero-initialize an Object of type T Means:
- if T is a scalar type (3.9), the Object is set to the value of 0 (zero) converted to T;
- if T is a non-union class type, each Nonstatic data Member and each base-class subobject is zero-initialized;
- if T is a Union type, the Object’s first named data Member is zero-initialized;
- if T is an array type, each element is zero-initialized;
- if T is a Reference type, no initialization is performed.

To default-initialize an Object of type T Means:
- if T is a non-POD class type (clause 9), the default constructor for T is called (and the initialization is Ill-Formed if T has no default accessible constructor);
- if T is an array type, each element is default-initialized;
- otherwise, the Object is zero-initialized.

To value-initialize an Object of type T Means:
- if T is a class type (clause 9) with a user-declared constructor (12.1), then the default constructor for T is called (and the initialization is Ill-Formed if T has no accessible default constructor);
- if T is a non-union class type without a user-declared constructor, then Every non-static data Member and base-class Component of T is value-initialized;
- if T is an array type, then each element is value-initialized;
- otherwise, the Object is zero-initialized

A program that calls for default-initialization or value-initialization of an Entity of Reference type is Ill-Formed. If T is a cv-Qualified type, the cv-unqualified version of T is used for These Definitions of zero-initialization, default-initialization, and value-initialization.

This is another of the C++ gems that we all love. :)