使用C++来编写Ruby程序扩展的教程

Ruby 最酷的功能之一就是使用 C/C++ 定义的应用程序编程接口 (API) 扩展它。Ruby 提供了 C 头文件 ruby.h，它随附提供了许多功能，可使用这些功能创建 Ruby 类、模块和更多内容。除了头文件，Ruby 还提供了其他几个高层抽象来扩展基于本地 ruby.h 构建的 Ruby，本文要介绍的是 Ruby Interface for C++ Extensions 或 Rice。
创建 Ruby 扩展

在进行任何 Ruby 的 C API 或 Rice 扩展前，我想明确地介绍一下创建扩展的标准过程：

•     您具有一个或多个 C/C++ 源代码，可使用它们构建共享库。
•     如果您使用 Rice 创建扩展，则需要将代码链接到 libruby.a 和 librice.a。
•     将共享库复制到同一文件夹，并将该文件夹作为 RUBYLIB 环境变量的一部分。
•     在 Interactive Ruby (irb) prompt/ruby 脚本中使用常见的基于 require 的加载。如果共享库名为 rubytest.so，只需键入 require 'rubytest' 即可加载共享库。

假设头文件 ruby.h 位于 /usr/lib/ruby/1.8/include 中，Rice 头文件位于 /usr/local/include/rice/include 中，并且扩展代码位于文件 rubytest.cpp 中。 清单 1 显示了如何编译和加载代码。
清单 1. 编译和加载 Ruby 扩展

bash# g++ -c rubytest.cpp –g –Wall -I/usr/lib/ruby/1.8/include \
  -I/usr/local/include/rice/include
bash# g++ -shared –o rubytest.so rubytest.o -L/usr/lib/ruby/1.8/lib \
  -L/usr/local/lib/rice/lib -lruby –lrice –ldl -lpthread
bash# cp rubytest.so /opt/test
bash# export RUBYLIB=$RUBYLIB:/opt/test
bash# irb
irb> require 'rubytest'
=> true

Hello World 程序

现在，您已经准备好使用 Rice 创建自己的首个 Hello World 程序。您使用名为 Test 的 Rice API 和名为 hello 的方法创建了一个类，用它来显示字符串 "Hello, World!"。当 Ruby 解释器加载扩展时，会调用函数 Init_<shared library name>。对于 清单 1 的 rubytest 扩展，此调用意味着 rubytest.cpp 已定义了函数 Init_rubytest。Rice 支持您使用 API define_class 创建自己的类。清单 2 显示了相关代码。
清单 2. 使用 Rice API 创建类

#include "rice/Class.hpp"
extern "C"
void Init_rubytest( ) { 
 Class tmp_ = define_class("Test");
}

当您在 irb 中编译和加载清单 2 的代码时，应得到 清单 3 所示的输出。
清单 3. 测试使用 Rice 创建的类

irb> require ‘rubytest'
=> true
irb> a = Test.new
=> #<Test:0x1084a3928>
irb> a.methods
=> ["inspect", "tap", "clone", "public_methods", "__send__", 
   "instance_variable_defined?", "equal?", "freeze", …]

注意，有几个预定义的类方法可供使用，比如 inspect。出现这种情况是因为，定义的 Test 类隐式地衍生自 Object 类（每个 Ruby 类都衍生自 Object；实际上，Ruby 中的所有内容（包括数字）都是基类为 Object 的对象）。

现在，为 Test 类添加一个方法。清单 4 显示了相关代码。
清单 4. 为 Test 类添加方法

void hello() {
  std::cout << "Hello World!";
}
extern "C"
 void Init_rubytest() {
   Class test_ = define_class("Test")
     .define_method("hello", &hello);
}

清单 4 使用 define_method API 为 Test 类添加方法。注意，define_class 是返回一个类型为 Class 的对象的函数；define_method 是 Module_Impl 类的成员函数，该类是 Class 的基类。下面是 Ruby 测试，验证所有内容是否都运行良好：

irb> require ‘rubytest'
=> true
irb> Test.new.hello
Hello, World!
=> nil

将参数从 Ruby 传递到 C/C++ 代码

现在，Hello World 程序已正常运行，尝试将参数从 Ruby 传递到 hello 函数，并让函数显示与标准输出 (sdtout) 相同的输出。最简单的方法是为 hello 函数添加一个字符串参数：

void hello(std::string args) {
  std::cout << args << std::endl;
}
extern "C"
 void Init_rubytest() {
   Class test_ = define_class("Test")
     .define_method("hello", &hello);
}

在 Ruby 环境中，以下是调用 hello 函数的方式：

irb> a = Test.new
<Test:0x0145e42112>
irb> a.hello "Hello World in Ruby"
Hello World in Ruby
=> nil

使用 Rice 最出色的一点是，无需进行任何特殊操作将 Ruby 字符串转换为 std::string。

现在，尝试在 hello 函数中使用字符串数组，然后检查如何将信息从 Ruby 传递到 C++ 代码。最简单的方式是使用 Rice 提供的 Array 数据类型。在头文件 rice/Array.hpp 中定义 Rice::Array，使用 Rice::Array 的方式类似于使用 Standard Template Library (STL) 容器。还要将常见的 STL 样式迭代器等内容定义为 Array 接口的一部分。清单 5 显示了 count 例程，该例程使用 Rice Array 作为参数。
清单 5. 显示 Ruby 数组

#include "rice/Array.hpp"

void Array_Print (Array a)  {
   Array::iterator aI = a.begin();
   Array::iterator aE = a.end();
   while (aI != aE) {
    std::cout << "Array has " << *aI << std::endl;
    ++aI;
   }
 }

现在，下面是此解决方案的魅力所在：假设您拥有 std::vector<std::string> 作为 Array_Print 参数。下面是 Ruby 抛出的错误：

>> t = Test.new
=> #<Test:0x100494688>
>> t.Array_Print ["g", "ggh1", "hh1"]
ArgumentError: Unable to convert Array to std::vector<std::string, 
  std::allocator<std::string> >
 from (irb):3:in `hello'
 from (irb):3

但是，使用此处显示的 Array_Print 例程，Rice 负责执行从 Ruby 数组到 C++ Array 类型的转换。下面是样例输出：

>> t = Test.new
=> #<Test:0x100494688>
>> t.Array_Print ["hello", "world", "ruby"]
Array has hello
Array has world
Array has ruby
=> nil

现在，尝试相反的过程，将 C++ 的数组传递到 Ruby 环境。请注意，在 Ruby 中，数组元素不一定是同一类型的。清单 6 显示了相关代码。
清单 6. 将数组从 C++ 传递到 Ruby

#include "rice/String.hpp"
#include "rice/Array.hpp"
using namespace rice; 

Array return_array (Array a) {
   Array tmp_;
   tmp_.push(1);
   tmp_.push(2.3);
   tmp_.push(String("hello"));
   return tmp_;
 }

清单 6 明确显示了您可以在 C++ 中创建具有不同类型的 Ruby 数组。下面是 Ruby 中的测试代码：

>> x = t.return_array
=> [1, 2.3, "hello"]
>> x[0].class
=> Fixnum
>> x[1].class
=> Float
>> x[2].class
=> String

如果我没有更改 C++ 参数列表的灵活性，会怎么样？

更常见的情况是具有这样的灵活性，您将发现 Ruby 接口旨在将数据转换为 C++ 函数，该函数的签名无法更改。例如，考虑需要将字符串数组从 Ruby 传递到 C++ 的情形。C++ 函数签名如下所示：

void print_array(std::vector<std::string> args)

实际上，您在这里寻找的是某种 from_ruby 函数，Ruby 数组使用该函数并将它转换为 std::vector<std::string>。这正是 Rice 提供的内容，具有下列签名的 from_ruby 函数：

template <typename T>
T from_ruby(Object );

对于需要转换为 C++ 类型的每种 Ruby 数据类型，需要针对模板详细说明 from_ruby 例程。例如，如果将 Ruby 数组传递到上述处理函数，清单 7 显示了应如何定义 from_ruby 函数。
清单 7. 将 ruby 数组转换为 std::vector<std::string>

template<>
std::vector<std::string> from_ruby< std::vector<std::string> > (Object o)  {
  Array a(o);
  std::vector<std::string> v;
  for(Array::iterator aI = a.begin(); aI != a.end(); ++aI)
    v.push_back(((String)*aI).str());
  return v;
  }

请注意，不需要显式地调用 from_ruby 函数。当从 Ruby 环境传递作为函数参数的 string 数组时，from_ruby 将它转换为 std::vector<std::string>。清单 7 中的代码并不完美，但是您已经看到，Ruby 中的数组具有不同类型。相反，您调用了 ((String)*aI).str()，以便从 Rice::String 获得 std::string。（str 是 Rice::String 的一种方法：查看 String.hpp 以了解有关的更多信息。）如果您处理的是最常见的情形，清单 8 显示了相关的代码。
清单 8. 将 ruby 数组转换为 std::vector<std::string>（通用情况）

template<>
std::vector<std::string> from_ruby< std::vector<std::string> > (Object o)  {
  Array a(o);
  std::vector<std::string> v;
  for(Array::iterator aI = a.begin(); aI != a.end(); ++aI)
    v.push_back(from_ruby<std::string> (*aI));
  return v;
  }

由于 Ruby 数组的每个元素仍然是类型为 String 的 Ruby 对象，因此可以假设 Rice 已定义了 from_ruby 方法，将此类型转换为 std::string，不需要进行其他操作。如果情况并非如此，则需要为此转换提供 from_ruby 方法。下面是 Rice 资源中 to_from_ruby.ipp 的 from_ruby 方法：

template<>
inline std::string from_ruby<std::string>(Rice::Object x) {
 return Rice::String(x).str();
}

在 Ruby 环境中测试此代码。首先传递所有字符串的数组，如 清单 9 所示。
清单 9. 验证 from_ruby 功能

>> t = Test.new
=> #<Test:0x10e71c5c8>
>> t.print_array ["aa", "bb"]
aa bb
=> nil
>> t.print_array ["aa", "bb", 111]
TypeError: wrong argument type Fixnum (expected String)
 from (irb):4:in `print_array'
 from (irb):4

和预期一样，首次调用 print_array 运行正常。由于没有 from_ruby 方法来将 Fixnum 转换为 std::string，因此第二次调用时，会导致 Ruby 解释器抛出 TypeError。有几种修复此错误的方法：例如，在 Ruby 调用期间，仅将字符串作为数组的一部分（比如 t.print_array["aa", "bb", 111.to_s]）来传递，或者是在 C++ 代码中，调用 Object.to_s。to_s 方法是 Rice::Object 接口的一部分，它会返回 Rice::String，它还有一个返回 std::string 的预定义 str 方法。清单 10 使用了 C++ 方法。
清单 10. 使用 Object.to_s 填充字符串向量

template<>
std::vector<std::string> from_ruby< std::vector<std::string> > (Object o)  {
  Array a(o);
  std::vector<std::string> v;
  for(Array::iterator aI = a.begin(); aI != a.end(); ++aI)
    v.push_back(aI->to_s().str());
  return v;
  }

通常，清单 10 中的代码更为重要，因为您需要处理用户定义的类的自定义字符串表示。

使用 C++ 创建一个具有变量的完整类

您已经了解了在 C++ 代码内如何创建 Ruby 类和相关函数。对于更通用的类，需要一种定义实例变量的方法，并提供一个 initialize 方法。要设置并获得 Ruby 对象实例变量的值，可以使用 Rice::Object::iv_set 和 Rice::Object::iv_get 方法。清单 11 显示了相关的代码。
清单 11. 在 C++ 中定义 initialize 方法

void init(Object self) {
   self.iv_set("@intvar", 121);
   self.iv_set("@stringvar", String("testing"));
 }
Class cTest = define_class("Test").
             define_method("initialize", &init);

使用 define_method API 将 C++ 函数声明为 Ruby 类方法时，可选择将 C++ 函数的第一个参数声明为 Object，并且 Ruby 会使用调用实例的引用来填充此 Object。然后，在 Object 上调用 iv_set 来设置实例变量。下面是接口在 Ruby 环境中的外观：

>> require 'rubytest'
=> true
>> t = Test.new
=> #<Test:0x1010fe400 @stringvar="testing", @intvar=121>

同样地，要返回实例变量，返回的函数需要接收在 Ruby 中引用对象的 Object，并对它调用 iv_get。清单 12 显示了相关的代码片段。
清单 12. 从 Ruby 对象检索值

void init(Object self) {
   self.iv_set("@intvar", 121);
   self.iv_set("@stringvar", String("testing"));
 }
int getvalue(Object self) { 
  return self.iv_get("@intvar");
}
Class cTest = define_class("Test").
             define_method("initialize", &init).
             define_method("getint", &getvalue);

将 C++ 类转换为 Ruby 类型

迄今为止，您已经将免费的函数（非类方法）包装为 Ruby 类方法。您已经将引用传递给 Ruby 对象，方法是使用第一个参数 Object 声明 C 函数。这种方法有用，但是在将 C++ 类包装为 Ruby 对象时，这种方法不够好用。要包装 C++ 类，仍需要使用 define_class 方法，除非现在您使用 C++ 类类型对它进行了 “模板化” 。清单 13 中的代码将 C++ 类包装为 Ruby 类型。
清单 13. 将 C++ 类包装为 Ruby 类型

class cppType {
  public:
   void print(String args) {
    std::cout << args.str() << endl;
   }
};
Class rb_cTest =
    define_class<cppType>("Test")
     .define_method("print", &cppType::print);

注意，如前所述，对 define_class 进行了模板化。尽管这种方法并不是适合所有此类。下面是您试图实例化类型 Test 的对象时，Ruby 解释器的记录：

>> t = Test.new
TypeError: allocator undefined for Test
 from (irb):3:in `new'
 from (irb):3

刚刚发生了什么事？您需要将构造函数显式地绑定到 Ruby 类型。（这是 Rice 的怪异之处之一。）Rice 为您提供了 define_constructor 方法来关联 C++ 类型的构造函数。您还需要包含头文件 Constructor.hpp。注意，即使在您的代码中没有显式构造函数，您也必须这样做。清单 14 提供了示例代码。
清单 14. 将 C++ 构造函数与 Ruby 类型关联起来

#include "rice/Constructor.hpp"
#include "rice/String.hpp"
class cppType {
  public:
  void print(String args) {
    std::cout << args.str() << endl;
   }
  };

Class rb_cTest =
    define_class<cppType>("Test")
     .define_constructor(Constructor<cppType>())
    .define_method("print", &cppType::print);

还可以将构造函数与使用 define_constructor 方法的参数列表关联起来。Rice 进行此操作的方法是为模板列表添加参数类型。例如，如果 cppType 有一个接收整数的构造函数，那么您必须将 define_constructor 作为 define_constructor(Constructor<cppType, int>()) 进行调用。关于此处的一条警告：Ruby 类型没有多个构造函数。因此，如果您有具有多个构造函数的 C++ 类型，并使用 define_constructor 将它们关联起来，那么从 Ruby 环境的角度讲，您可以像源代码最后一个 define_constructor 定义的那样，初始化具有（或没有）参数的类型。清单 15 解释了刚刚讨论的所有内容。
清单 15. 将构造函数与参数关联起来

class cppType {
  public:
   cppType(int m) {
    std::cout << m << std::endl;
   }
   cppType(Array a) {
    std::cout << a.size() << std::endl;
   }
   void print(String args) {
    std::cout << args.str() << endl;
   }
  };
Class rb_cTest =
    define_class<cppType>("Test")
     .define_constructor(Constructor<cppType, int>())
     .define_constructor(Constructor<cppType, Array>())
     .define_method("print", &cppType::print);

下面是来自 Ruby 环境的记录。注意，最后关联的构造函数是 Ruby 理解的构造函数：

>> t = Test.new 2
TypeError: wrong argument type Fixnum (expected Array)
 from (irb):2:in `initialize'
 from (irb):2:in `new'
 from (irb):2
>> t = Test.new [1, 2]
2
=> #<Test:0x10d52cf48>

将新 Ruby 类型定义为模块的一部分

从 C++ 定义新 Ruby 模块可归结为调用 define_module。要定义仅作为所述模块一部分的类，请使用 define_class_under 而不是常用的 define_class 方法。define_class_under 的第一个参数是模块对象。根据 清单 14，如果您打算将 cppType 定义为名为 types 的 Ruby 模块的一部分，清单 16 显示了如何进行此操作。
清单 16. 将类型声明为模块的一部分

#include "rice/Constructor.hpp"
#include "rice/String.hpp"
class cppType {
  public:
  void print(String args) {
    std::cout << args.str() << endl;
   }
  };

Module rb_cModule = define_module("Types");
Class rb_cTest =
    define_class_under<cppType>(rb_cModule, "Test")
     .define_constructor(Constructor<cppType>())
    .define_method("print", &cppType::print);

下面是在 Ruby 中使用相同声明的方法：

>> include Types
=> Object
>> y = Types::Test.new [1, 1, 1]
3
=> #<Types::Test:0x1058efbd8>

注意，在 Ruby 中，模块名称和类名称必须以大写字母开头。如果您将模块命名为 types 而不是 Types，Rice 不会出错。

使用 C++ 代码创建 Ruby 结构

您在 Ruby 中使用 struct 构造函数来快速创建样本 Ruby 类。清单 17 显示了使用名为 a、ab 和 aab 的三个变量创建类型 NewClass 的新类的方法。
清单 17. 使用 Ruby Struct 创建新类

>> NewClass = Struct.new(:a, :ab, :aab)
=> NewClass
>> NewClass.class
=> Class
>> a = NewClass.new
=> #<struct NewClass a=nil, ab=nil, aab=nil>
>> a.a = 1
=> 1
>> a.ab = "test"
=> "test"
>> a.aab = 2.33
=> 2.33
>> a
=> #<struct NewClass a=1, ab="test", aab=2.33>
>> a.a.class
=> Fixnum
>> a.ab.class
=> String
>> a.aab.class
=> Float

要在 C++ 中进行 清单 17 的等效编码，您需要使用头文件 rice/Struct.hpp 中声明的 define_struct( ) API。此 API 返回 Rice::Struct。您将此 struct 创建的 Ruby 类与该类所属的模块关联起来。这是 initialize 方法的目的。使用 define_member 函数调用定义各个类成员。注意，您已经创建了一个新的 Ruby 类型，可惜您没有将任何 C++ 类型或函数与它关联起来。下面是创建名为 NewClass 的类的方法：

#include "rice/Struct.hpp"
…
Module rb1 = define_module("Types");
define_struct().
    define_member("a").
    define_member("ab").
    define_member("aab").
    initialize(rb1, "NewClass");

结束语

本文介绍了一些背景知识：使用 C++ 代码创建 Ruby 对象，将 C 样式的函数作为 Ruby 对象方法进行关联，在 Ruby 和 C++ 之间转换数据类型，创建实例变量，以及将 C++ 类包装为 Ruby 类型。您可以使用 ruby.h 头文件和 libruby 实现所有这些操作，但是您需要编写大量样板代码来结束所有操作。Rice 使这些工作变得更加简单。在这里，祝您使用 C++ 针对 Ruby 环境编写新扩展愉快！ world!