对象数组，Java和C ++之间的区别

Question

I am new to C++ and I am porting over a Java project to C++.

Consider the following Java code, where Piece is a class representing a chess piece:

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

It creates an array where all the entries are null.

How can I achieve the same thing in C++? I tried:

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

But this will create an array with all the entries initialized with the default constructor.

Thanks

Edit: I want the C++ code to be efficient/elegant and I do not care nor wnant to copy paste from Java to C++. I am happy to heavily modify the code structure if needed.

Edit 2: The code is for chess programm, the size of the array will never change and performance is critical.

Answer 1

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.

Answer 2

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;

Answer 3

The answer depends, because contrary to Java, in C++ you have different ownership semantics and object lifetime management (the two go hand in hand).

If you want to model objects similar to java, you would write:

using PiecePtr = std::shared_ptr<Piece>;
std::array<std::array<PiecePtr, 8>, 8> Pieces;

The shared_ptr has similar semantics to a java object (pass it around wherever and it's lifetime is guaranteed as long as there are references to it).

If you want to model observed objects (ie the array doesn't own them), you should write:

using PiecePtr = Piece*;
std::array<std::array<PiecePtr, 8>, 8> Pieces;

This ensures that when the Pieces object gets destroyed, the actual pieces themselves remain in memory.

If you want to model unique objects, owned by the Pieces array, you should use:

using PiecePtr = std::unique_ptr<Piece>;
std::array<std::array<PiecePtr, 8>, 8> Pieces;

This ensures that when the Pieces object gets destroyed, the actual pieces themselves get destroyed as well.

Answer 4

在C ++中你会做类似的事情：

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

Answer 5

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.

Answer 6

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.

Answer 7

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

Answer 8

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.

Answer 9

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 eg

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