Via this->Pointer oder via Reference?

Tomahawk

So sieht's aktuell aus:

A (wie "alt")

struct board_c {
  // variables
  sintx piece[SQUARES];
  sintx moves[SQUARES];
  uint64 key_list[1024];
  uint64 key_pawns;
  uint64 key_pieces;
  uint64 key_material;
  uint64 white_pawn_bitboard;
  uint64 white_knight_bitboard;
  uint64 white_bishop_bitboard;
  uint64 white_rook_bitboard;
  uint64 white_queen_bitboard;
  uint64 white_bitboard;
  uint64 black_pawn_bitboard;
  uint64 black_knight_bitboard;
  uint64 black_bishop_bitboard;
  uint64 black_rook_bitboard;
  uint64 black_queen_bitboard;
  uint64 black_bitboard;
  // more...
};

// functions

extern sintx generate_captures_w(const board_c & board, sintx move_list[256]);
extern sintx generate_captures_b(const board_c & board, sintx move_list[256]);
extern sintx generate_non_captures_w(const board_c & board, sintx move_list[256]);
extern sintx generate_non_captures_b(const board_c & board, sintx move_list[256]);
extern sintx generate_moves_w(const board_c & board, sintx move_list[256]);
extern sintx generate_moves_b(const board_c & board, sintx move_list[256]);
// more...

oder besser doch so:

B (wie vielleicht "besser")

class board_c {
private:
  // variables
  sintx piece[SQUARES];
  sintx moves[SQUARES];
  uint64 key_list[1024];
  uint64 key_pawns;
  uint64 key_pieces;
  uint64 key_material;
  uint64 white_pawn_bitboard;
  uint64 white_knight_bitboard;
  uint64 white_bishop_bitboard;
  uint64 white_rook_bitboard;
  uint64 white_queen_bitboard;
  uint64 white_bitboard;
  uint64 black_pawn_bitboard;
  uint64 black_knight_bitboard;
  uint64 black_bishop_bitboard;
  uint64 black_rook_bitboard;
  uint64 black_queen_bitboard;
  uint64 black_bitboard;
  // more...

public:
  // functions
  sintx generate_captures_w(sintx move_list[256]) const;
  sintx generate_captures_b(sintx move_list[256]) const;
  sintx generate_non_captures_w(sintx move_list[256]) const;
  sintx generate_non_captures_b(sintx move_list[256]) const;
  sintx generate_moves_w(sintx move_list[256]) const;
  sintx generate_moves_b(sintx move_list[256]) const;
  // more...
};

Überlegungen

In A habe ich zwei grosse Vorteile. Innerhalb der Functions darf ich nur via board.member zugreifen. Daher habe ich bei der Wahl der Variablennamen innerhalb der Functions eine grössere Freiheit. Ausserdem erkenne ich sofort, welche Variable zu board_c gehört und welche nur lokal ist.

In B habe ich den offensichtlichen Vorteil die Member-Variable endlich nach "aussen" via private zu schützen. Und das ist auch genau wieder ein Problem (Overhead). Ich muss dann für jede Variable eine kleine Inline-Function schreiben, die die entsprechende Variable nach aussen lesbar macht:

inline uint64 board_c::white_bitboard_get(void) const {
  return white_bitboard;
}

Ist es sinnvoll den Aufbau wie in B zu verwenden? Bei se Wei, es gibt von den board_c 4-5 Instanzen. Insofern lässt sich B vielleicht doch rechtfertigen?

Danke schonmal für eure Antworten.

PS:
*Baue gerade meine C-Schachengine nach C++ um, aber nur soweit, es auch wirklich sinnvoll ist. Das heisst, Strukturen via Reference statt via Pointer zu übergeben. Inline-Functions statt Defines. Und Operatoren für den Heap-Speicher. Jetzt plane ich eben noch die Strukturen in Klassen umzubauen, sofern sinnvoll!
*

drakon

Der Sinn von Klassen ist ja Abstraktion. Man sagt dem User nicht, WIE etwas gemacht wird, sondern nur, dass die Klasse etwas machen soll. Wie das geschieht kann/sollte dem User egal sein. Wenn du jetzt jede Variable mit getter und setter koppelst, dann macht der User ja doch irgendwie alles selbst.

Via this-&gt;Pointer oder via Reference?

Via this->Pointer oder via Reference?