我正在用 Rcpp 开发一个简单的库来构建霍夫曼树。它有一个工作的 R 接口(interface)，我可以从其他包调用，但我也想直接从我正在开发的其他基于 Rcpp 的包中的 C++ 代码调用 C++ 函数。

我已经想出如何将第一个包的 header 放在 inst/include 目录中，以便它在第二个包中可用。但是，当在第二个包的 NAMESPACE 文件中调用 useDynLib 以加载调用第一个包中的函数的 C++ 代码时，我得到函数的 undefined symbol 错误 I我正在尝试使用。我在 Import、Depends 和 LinkingTo 下的第二个包的 DESCRIPTION 文件中列出了第一个包。

这是我第一次尝试做任何基于非 R 的包，我正在通过 Rstudio 的“Build & Reload”命令进行所有开发，并在创建包时使用“Package w/Rcpp”选项来生成初始目录结构。

最佳答案

在 R 中执行此操作的一般机制是通过 R_RegisterCCallable 和 R_GetCCallable 使函数指针可用。参见 R-exts举个例子。

这意味着符号是根据需要动态解析的——您实际上不需要“链接”到其他包本身；您只需要标题，以便稍后在执行代码时可以正确解析符号。请注意，LinkingTo: 字段实际上用词不当——它只是为您提供 header ，实际上并没有链接您到(为该)包生成的库。 p>

幸运的是，这可以通过 Rcpp::interfaces 自动完成属性，本质上是在 RcppExports.cpp 中自动生成 R_RegisterCCallable 入口点，并在生成的头文件中使用 R_GetCCallable 提供包装函数。

例如，假设我有一个名为 RcppInterfaces 的傻包，它包含在 src/test.cpp 中(DESCRIPTION 有 Rcpp in Includes: 和 LinkingTo:)。请注意 //[[Rcpp::interfaces(r, cpp)]] 注释，它向 Rcpp 发出信号，表明该文件应该同时获取 R 导出和 C++ header 导出.

// [[Rcpp::interfaces(r, cpp)]]

#include <Rcpp.h>

// [[Rcpp::export]]
void hello() {
    Rcpp::Rcout << "Hello!\n";
}

如果我调用 Rcpp::compileAttributes()，您将看到以下“内容”写入 RcppExports.cpp:

// This file was generated by Rcpp::compileAttributes
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

#include <Rcpp.h>
#include <string>
#include <set>

using namespace Rcpp;

// hello
void hello();
static SEXP RcppInterfaces_hello_try() {
BEGIN_RCPP
    {
        hello();
    }
    return R_NilValue;
END_RCPP_RETURN_ERROR
}
RcppExport SEXP RcppInterfaces_hello() {
    SEXP __result;
    {
        Rcpp::RNGScope __rngScope;
        __result = PROTECT(RcppInterfaces_hello_try());
    }
    Rboolean __isInterrupt = Rf_inherits(__result, "interrupted-error");
    if (__isInterrupt) {
        UNPROTECT(1);
        Rf_onintr();
    }
    Rboolean __isError = Rf_inherits(__result, "try-error");
    if (__isError) {
        SEXP __msgSEXP = Rf_asChar(__result);
        UNPROTECT(1);
        Rf_error(CHAR(__msgSEXP));
    }
    UNPROTECT(1);
    return __result;
}

// validate (ensure exported C++ functions exist before calling them)
static int RcppInterfaces_RcppExport_validate(const char* sig) { 
    static std::set<std::string> signatures;
    if (signatures.empty()) {
        signatures.insert("void(*hello)()");
    }
    return signatures.find(sig) != signatures.end();
}

// registerCCallable (register entry points for exported C++ functions)
RcppExport SEXP RcppInterfaces_RcppExport_registerCCallable() { 
    R_RegisterCCallable("RcppInterfaces", "RcppInterfaces_hello", (DL_FUNC)RcppInterfaces_hello_try);
    R_RegisterCCallable("RcppInterfaces", "RcppInterfaces_RcppExport_validate", (DL_FUNC)RcppInterfaces_RcppExport_validate);
    return R_NilValue;
}

请注意，大部分早期内容都是样板文件，可确保函数的异常安全版本可调用；最后，您基本上拥有了为其他包注册可调用函数的机制。

在 inst/include/RcppInterfaces_RcppExports.h 中，我们有:

// This file was generated by Rcpp::compileAttributes
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

#ifndef __RcppInterfaces_RcppExports_h__
#define __RcppInterfaces_RcppExports_h__

#include <Rcpp.h>

namespace RcppInterfaces {

    using namespace Rcpp;

    namespace {
        void validateSignature(const char* sig) {
            Rcpp::Function require = Rcpp::Environment::base_env()["require"];
            require("RcppInterfaces", Rcpp::Named("quietly") = true);
            typedef int(*Ptr_validate)(const char*);
            static Ptr_validate p_validate = (Ptr_validate)
                R_GetCCallable("RcppInterfaces", "RcppInterfaces_RcppExport_validate");
            if (!p_validate(sig)) {
                throw Rcpp::function_not_exported(
                    "C++ function with signature '" + std::string(sig) + "' not found in RcppInterfaces");
            }
        }
    }

    inline void hello() {
        typedef SEXP(*Ptr_hello)();
        static Ptr_hello p_hello = NULL;
        if (p_hello == NULL) {
            validateSignature("void(*hello)()");
            p_hello = (Ptr_hello)R_GetCCallable("RcppInterfaces", "RcppInterfaces_hello");
        }
        RObject __result;
        {
            RNGScope __rngScope;
            __result = p_hello();
        }
        if (__result.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (__result.inherits("try-error"))
            throw Rcpp::exception(as<std::string>(__result).c_str());
        return Rcpp::as<void >(__result);
    }

}

#endif // __RcppInterfaces_RcppExports_h__

这是一些更加异常安全的样板文件，但有趣的部分是 R_GetCCallable 调用，它允许其他包作者通过 R_GetCCallable“仅使用”该函数> 直接在函数调用中填充内联和管理(使用必要时填充一次的静态指针)。

因此，对于这个RcppInterfaces 包的用户而言，他们可以调用

RcppInterfaces::hello()

在他们的代码中，我们只是自动确保函数指针在运行时被查找和使用(安全!)，使用 R 自己的机制。

关于c++ - 如何在 R 包之间共享基于 Rcpp 的库中的 C++ 函数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27079811/