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 扩展
|
1
2
3
4
5
6
7
8
9
|
bash# g++ -c rubytest.cpp –g –Wall -I/usr/lib/ruby/1.8/include \ -I/usr/local/include/rice/includebash# g++ -shared –o rubytest.so rubytest.o -L/usr/lib/ruby/1.8/lib \ -L/usr/local/lib/rice/lib -lruby –lrice –ldl -lpthreadbash# cp rubytest.so /opt/testbash# export RUBYLIB=$RUBYLIB:/opt/testbash# irbirb> 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 创建类
|
1
2
3
4
5
|
#include "rice/Class.hpp"extern "C"void Init_rubytest( ) { Class tmp_ = define_class("Test");} |
当您在 irb 中编译和加载清单 2 的代码时，应得到 清单 3 所示的输出。
清单 3. 测试使用 Rice 创建的类
|
1
2
3
4
5
6
7
|
irb> require ‘rubytest'=> trueirb> 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 类添加方法
|
1
2
3
4
5
6
7
8
|
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 测试，验证所有内容是否都运行良好：
|
1
2
3
4
5
|
irb> require ‘rubytest'=> trueirb> Test.new.helloHello, World!=> nil |
将参数从 Ruby 传递到 C/C++ 代码
现在，Hello World 程序已正常运行，尝试将参数从 Ruby 传递到 hello 函数，并让函数显示与标准输出 (sdtout) 相同的输出。最简单的方法是为 hello 函数添加一个字符串参数：
|
1
2
3
4
5
6
7
8
|
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 函数的方式：
|
1
2
3
4
5
|
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 数组
|
1
2
3
4
5
6
7
8
9
10
|
#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 抛出的错误：
|
1
2
3
4
5
6
7
|
>> 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 类型的转换。下面是样例输出：
|
1
2
3
4
5
6
7
|
>> t = Test.new=> #<Test:0x100494688>>> t.Array_Print ["hello", "world", "ruby"]Array has helloArray has worldArray has ruby=> nil |
现在，尝试相反的过程，将 C++ 的数组传递到 Ruby 环境。请注意，在 Ruby 中，数组元素不一定是同一类型的。清单 6 显示了相关代码。
清单 6. 将数组从 C++ 传递到 Ruby
|
1
2
3
4
5
6
7
8
9
10
11
|
#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 中的测试代码：
|
1
2
3
4
5
6
7
8
|
>> 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++ 函数签名如下所示：
|
1
|
void print_array(std::vector<std::string> args) |
实际上，您在这里寻找的是某种 from_ruby 函数，Ruby 数组使用该函数并将它转换为 std::vector<std::string>。这正是 Rice 提供的内容，具有下列签名的 from_ruby 函数：
|
1
2
|
template <typename T>T from_ruby(Object ); |
对于需要转换为 C++ 类型的每种 Ruby 数据类型，需要针对模板详细说明 from_ruby 例程。例如，如果将 Ruby 数组传递到上述处理函数，清单 7 显示了应如何定义 from_ruby 函数。
清单 7. 将 ruby 数组转换为 std::vector<std::string>
|
1
2
3
4
5
6
7
8
|
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>（通用情况）
|
1
2
3
4
5
6
7
8
|
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 方法：
|
1
2
3
4
|
template<>inline std::string from_ruby<std::string>(Rice::Object x) { return Rice::String(x).str();} |
在 Ruby 环境中测试此代码。首先传递所有字符串的数组，如 清单 9 所示。
清单 9. 验证 from_ruby 功能
|
1
2
3
4
5
6
7
8
9
|
>> 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 填充字符串向量
|
1
2
3
4
5
6
7
8
|
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 方法
|
1
2
3
4
5
6
|
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 环境中的外观：
|
1
2
3
4
|
>> require 'rubytest'=> true>> t = Test.new=> #<Test:0x1010fe400 @stringvar="testing", @intvar=121> |
同样地，要返回实例变量，返回的函数需要接收在 Ruby 中引用对象的 Object，并对它调用 iv_get。清单 12 显示了相关的代码片段。
清单 12. 从 Ruby 对象检索值
|
1
2
3
4
5
6
7
8
9
10
|
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 类型
|
1
2
3
4
5
6
7
8
9
|
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 解释器的记录：
|
1
2
3
4
|
>> t = Test.newTypeError: allocator undefined for Test from (irb):3:in `new' from (irb):3 |
刚刚发生了什么事？您需要将构造函数显式地绑定到 Ruby 类型。（这是 Rice 的怪异之处之一。）Rice 为您提供了 define_constructor 方法来关联 C++ 类型的构造函数。您还需要包含头文件 Constructor.hpp。注意，即使在您的代码中没有显式构造函数，您也必须这样做。清单 14 提供了示例代码。
清单 14. 将 C++ 构造函数与 Ruby 类型关联起来
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#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. 将构造函数与参数关联起来
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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 理解的构造函数：
|
1
2
3
4
5
6
7
8
|
>> t = Test.new 2TypeError: 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. 将类型声明为模块的一部分
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#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 中使用相同声明的方法：
|
1
2
3
4
5
|
>> 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 创建新类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
>> 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 的类的方法：
|
1
2
3
4
5
6
7
8
|
#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!
