使用扩展保持 C 数组和 Ruby 数组同步？

Question

我正在用 Ruby 编写 C 扩展，但遇到了一些问题。我有几个 C 结构，这是一个简化版本：

typedef struct
{
  int score;
} Player;

typedef struct
{
  int numPlayers;
  Player *players;
} Game;

我将这些很好地封装在一个 C 扩展中。我已经为每个结构设置了方法，这是玩家的，因为这是我感兴趣的：

static VALUE players(VALUE self)
{
  Game *g;
  Data_Get_Struct(self, Game, g);
  VALUE players = rb_ary_new();
  for (int i = 0; i<g->numPlayers; i++)
  {
    //cPlayer is the ruby class I defined in my Init method
    VALUE player = Data_Wrap_Struct(cPlayer, NULL, NULL, &g->players[i]);
    rb_ary_push(players, player);
  }
  return players;
}

static VALUE set_players(VALUE self, VALUE players)
{
  Game *g;
  Data_Get_Struct(self, Game, g);
  free(g->players);
  g->players = malloc(sizeof(Player)*RARRAY_LEN(players));
  for (int i = 0; i<RARRAY_LEN(players); i++)
  {
    VALUE iValue = INT2NUM(i);
    VALUE player = rb_ary_aref(1, &iValue, players);
    Player *cPlayer;
    Data_Struct_Get(player, Player, cPlayer);
    memcpy(&g->players[i], cPlayer, sizeof(Player));
  }
  return Qnil;
}

然后，在我的 Ruby 代码中，我可以这样做：

g = Game.new
g.players = [Player.new, Player.new, Player.new]
g.players.each {|player| player.score = 5}

这很好用。但是，我不知道该怎么做：

g.players << Player.new
 => [<Player0>, <Player1>, <Player2>, <Player3>]
g.players
 => [<Player0>, <Player1>, <Player2>]
g.players[0] = Player.new
 => [<Player4>, <Player1>, <Player2>]
g.players
 => [<Player0>, <Player1>, <Player2>]

显然，问题是当我访问数组时，它每次都会计算一个新数组。因此，当我添加或追加一个播放器时，该数组会发生变化，但底层播放器数组保持不变。我觉得我必须有两个数组，一个在 Ruby 中，一个在 C 中。每当我将一些玩家添加到 C 数组中时，比如在 initialize_game 函数中，我必须更新 Ruby 数组，并且每当 Ruby 数组更新时，必须有某种回调来更新 C 数组。但是，我不确定该怎么做。

Answer 1

您可以在结构中存储一个 Ruby VALUE 引用：

typedef struct
{
  int numPlayers;
  VALUE players;
} Game;

你需要单独初始化它（我通常实现一个init函数并在alloc例程之后调用它）。

此外，您必须在被问到时使用rb_gc_mark 标记值 - 您需要在Data_Wrap_Struct 中填写那些NULL 引用才能与Ruby 的GC 配合使用。

你真的应该已经提供一个销毁函数，否则你会出现内存泄漏：

例如

Data_Wrap_Struct( cGame, game_gc_mark, game_destroy, new_game );

game_gc_mark 应如下所示：

void game_gc_mark( Game *g ) {
  rb_gc_mark( g->players );
  return;
}

game_destroy 应如下所示：

void game_destroy( Game *g ) {
  xfree( g );
  return;
}

请注意，如果您这样做，则无需为数组内的 Array 或 Player 对象处理内存管理 - Ruby 的 GC 将为您处理，只要您提供类似的方法来销毁 Player 对象.

这样做的好处是所有对象都可以像普通 Ruby 一样访问，而在幕后，数据存储在结构中，可以有效地用于您想要在 C 中实现的任何方法。没有来回转换，没有生成新的 Ruby 对象以遵循关系，只需在需要时加快速度并有时间编写 C。

缺点是您需要针对 Ruby 代码对 player 数组的操作进行防御性编码，否则如果您假设您有 Player 对象，则可能会出现段错误，但实际上一个错误导致它们成为其他类。