C++ vs Java: Arrays of Objects

What do you mean, you're trying to see the difference and you're confused? The difference is exactly what you've stated. The C++ code creates an array of 10 Student objects that are default-initialized [1], and the Java code creates an array of 10 references so no Student constructors are called until you do it yourself.

Maybe your question is why C++ and Java differ. That's because a Student[] in Java is an array of Student references, so the true C++ equivalent would be an array of Student pointers,

Student** sp = new Student*[10]

which you would indeed have to follow up with

sp[0] = new Student(args);
...
sp[9] = new Student(args);

analogously to your Java example.

Now, if you want an array of 10 Student objects in C++ initialized using a constructor other than a default constructor, you have to do it in two steps: first allocate memory for 10 Student objects, then manually construct the Student objects over that memory using placement new. I do not endorse this style of coding. It is very confusing even to experienced C++ programmers.

typedef Student SA[10]; // SA means array of 10 Students
SA* psa = static_cast<SA*>(::operator new(sizeof(SA)));
SA& sa = *psa; // sa refers to an array of 10 Students
new (&sa[0]) Student(args); // construct the Student object
// ...
new (&sa[9]) Student(args);
// later
for (int i = 0; i < 10; i++) {
    sa[i].~Student(); // destroy the Student object
}
::operator delete(psa); // deallocate the memory for the array

Use a damn vector.

[1] Note: In C++, for a class, default-initialized means that the default constructor is called; for an array, it means each element is default-initialized; and for an arithmetic, pointer, reference, or enum type, it means it's not initialized at all.

Short answer:

Those two declarations are different. The C++ one allocates an array of Student objects, while the Java one allocates an array of references to Student objects.

Long answer:

The difference is that, in Java when you declare an object:

Student s;

It creates a reference (similar to a pointer in C++) to a Student and initializes the reference to null. You can then later assign a Student object to that reference variable with s = new Student().

But in C++ when you declare an object:

Student s;

It creates an actual object (not a reference to an object as in Java). And thus the object must be immediately instantiated.

So in Java, when you do this:

Student [] sa = new Student[10];

It actually creates an array of references to Student objects (not an array of actual Student objects), and they are all initalized to null references.

...I think in case of Java though, no instances are created when this statement executes and instead only memory is reserved to hold 10 references to Student instances.

So yes, you're right.

But in C++ this:

Student* sp = new Student[10];

dynamically allocates an array of actual Student objects. Again, not references as in Java, so each object will be instantiated immediately.

I believe this creates an array of 10 instances of Student, each calling the default constructor with no arguments.

Correct as well.

So in Java after declaring the array of references you can then instantiate the actual objects and assign them to those references in the array with this:

sa[0] = new Student(*arguments*);

But in C++ the Student objects in the array were already instantiated, so this is not needed.

Bonus: Array of pointers in C++

In C++, you can also declare an array of pointers to postpone object instantiation, similar to the Java array of references:

Student** spp = new Student*[10];

This will create an array of 10 pointers to Student objects. You can then instantiate the objects when needed and assign their memory addresses to the pointers:

spp[0] = new Student(*arguments*);

This looks a lot like Java, but is actually not generally recommended in C++. In fact, using new in C++ should be avoided most of the time.

Here's a round about way of accomplishing what you are hoping to using the new operator.

#include <new>

struct Student
{
   Student(int ){}
};


int main()
{
   // Allocate memory for 10 Students.
   // Don't construct Student objects yet.
   char* cp = new char[10*sizeof(Student)];

   // Now construct the Student objects using
   // placement new
   Student* sp[10];
   for ( int i = 0; i < 10; ++i )
   {
      sp[i] = new (cp + sizeof(Student)*i) Student(10);
   }

   // Use the Student objects
   // ...
   // ...

   // Call the destructor on the Students explicitly.
   for ( int i = 0; i < 10; ++i )
   {
      sp[i]->~Student();
   }

   // Deallocate the memory.
   delete [] cp;
}