Array of objects, difference between Java and C++

The simplest way to declare an 8x8 array of optional objects in C++ is like so:

boost::optional<Piece> myPieces[8][8];

The boost::optional type represents an optional object (like your nullable references in Java) that doesn't have all the pitfalls of using pointer types. It should be available as part of the standard library in the next few years.

You may prefer to use the std::array type, which is an encapsulation of fixed-size arrays that allows them to be treated as first-class citizens and also provides a nicer interface:

std::array<std::array<boost::optional<Piece>, 8>, 8> myPieces;

If you want to be able to resize your arrays at run-time, consider std::vector instead.

As you want it performant, and right for C++ instead of a dumb translation, how about this:

Use a size-1 POD-type for piece.
Add all the convenience-methods you might want to it:

struct Piece {
    unsigned char value;
    constexpr Piece() : value() {}
    constexpr operator bool() const {return !value;}
    constexpr bool empty() const {return *this;};
    constexpr bool black() const {return value&0x80;}
    constexpr bool white() const {return value && !black();}
    constexpr unsigned piece() const {return value & 0x7f;}
};

Now that would be an equivalent raw array:

Piece board[8][8];

Or use std::array:

#include <array>
std::array<std::array<Piece, 8>, 8> board;

In C++ you'd do something like:

std::vector<std::vector<std::unique_ptr<Pieces>>> myPieces;

Semantically equivalent would be:

Piece* myPieces[8][8]

as java only knows objects on the heap, pointers.

As Piece probably is not a final class, but has King, Queen, this is the way to go.

In c++, newly created object (even in array) is created with default constructor. That's one of the important differences with java. If you want to call constructors individually, just use vector of vectors and add each one of them.

I have no experience with java but I believe from what I got that this could be a good replacement in C++:

std::array<std::array<unique_ptr<foo>, 8>, 8> arr = {};

if(arr[2][3].get() == nullptr) // Can check for null elements
    std::cout << "this is null";

arr[3][4].reset(new foo()); // Initialize an element

• smart pointer avoids memory leaks
• std::array provides performances comparable to a normal C array
• aggregate initialization provides each pointer a null value
• fixed size as the java array

So you want to make a Chess engine and performance is critical. There are several online tutorials for this. Speed is important for a Chess AI so it can consider more moves per second, but you may need to sacrifice elegance for that.

You can either store the piece values in the board array directly, or store the pieces in a separate backing array and create the board as pointers to these pieces. There are some advantages to the second approach which I can't remember right now.

std::array<std::array<Peice *, 8>, 8> Board;
std::array<Piece, 32> Pieces;

You can represent an empty cell as a null pointer.

If you want everything in the same array, you can simply use

std::array<std::array<Peice, 8>, 8> Board;

But you will need to create a "dummy" piece value to represent an empty cell.

Note there is no dynamic memory allocation and the data is compact in memory so better cache performance.

Piece could be an enum or a struct with some useful getter functions, such as IsWhite.

In C++, you have to declare as:

Piece *** myPieces;

then, allocate as:

myPieces = new Piece **[8];

then,

for (int i = 0; i < 8; i++) {
  myPieces[i] = new Piece *; 
}

Now, if you do,

myPieces[0][0] = new Piece(); // C++, calls default constructor of Piece

In Java,

Piece[][] myPieces; 
myPieces = new Piece[8][8];

now, if you do,

myPieces[0][0] = new Piece(); // Java, calls default constructor of Piece

Since you have 8x8 known already, you may also declare as (in C++):

Piece * myPieces[8][8]; // 64 pointers preallocated as 8 rows, 8 cols

then,

Now, if you do,

for (int i = 0; i < 8; i++) {
  for (int j = 0; j < 8; j++) {
    myPieces[i][j] = new Piece(); // or new Pawn or new Knight etc, subclass of Piece
}}

or allocate as needed e.g.

myPieces[0][0] = new Piece(); // or new Pawn or new Knight etc, subclass of Piece