Question

我正在使用Rcpp为C ++库实现R包。该库实现了一个抽象类的几个派生类。函数初始化新的派生类，并将其指针作为抽象类返回。是否可以在不更改C ++库的情况下使用Rcpp为R获得类似的构造？

这是一个简化的可复制示例：

#include <iostream>
#include <string>
using namespace std;

// abstract class
class Base {
  public:
    virtual ~Base() {}
    virtual std::string name() const = 0;
    virtual Base* getNew() const = 0;
};

// derived class
class Derived: public Base {
  public:
    Derived() : Base() {}
    virtual std::string name() const { return "Derived"; }
    virtual Derived* getNew() const { return new Derived(); };
};

Base *newDerived( const std::string &name ) {
  if ( name == "d1" ){
    return new Derived ;
  } else {
    return 0 ;
  }
};

int main( void ) {
    Base* b = newDerived( "d1" ) ;
    cout << b->name() << endl ;
    return(1);
}

compiled代码的输出为：Derived

我当前的版本使用Rcpp::RCPP_MODULE和Rcpp::XPtr。但是，此版本不能像C ++实现那样使用：

#include <Rcpp.h>
using namespace Rcpp;

//... Base and Derived class and newDerived function implementations ... //

// wrapper function for pointer
typedef Base* (*newDerivedPtr)(const std::string& name);

//[[Rcpp::export]]
Rcpp::XPtr< newDerivedPtr > getNewDerived(const std::string type) {
  return(Rcpp::XPtr< newDerivedPtr >(new newDerivedPtr(&newDerived)));
}

RCPP_MODULE(mod) {
  Rcpp::class_< Base >("Base")
  ;

  Rcpp::class_< Derived >("Derived")
    .derives<Base>("Base")
    .default_constructor()
    .method("name", &Derived::name)
  ;
}

执行示例：

(dv = new(Derived))
# C++ object <0x101c0ce20> of class 'Derived' <0x101b51e00>
dv$name()
# [1] "Derived"
(dvptr = getNewDerived("d1"))
# pointer: 0x101c82770> // WANTED: C++ Object <0x...> of class 'Base' <0x...>

Answer 1

让我重新短语的问题是：你有一个类Derived与非公共构造。创建此类的实例的唯一方法是通过工厂方法newDerived。此工厂方法不返回一个指向Derived，但一个指针Base，从中Derived导出。

如果正确，则可以使用expose class in Rcpp - factory instead of constructor中显示的技术。不过，您必须确保公开Base类：

#include <Rcpp.h>
using namespace Rcpp;

// abstract class
class Base {
  public:
    virtual ~Base() {}
    virtual std::string name() const = 0;
};

// derived class
class Derived1: public Base {
  public:
    Derived1() : Base() {}
    virtual std::string name() const { return "Derived1"; }
};

// derived class
class Derived2: public Base {
  public:
    Derived2() : Base() {}
    virtual std::string name() const { return "Derived2"; }
};

Base *newBase( const std::string &name ) {
  if ( name == "d1" ){
    return new Derived1 ;
  } else if ( name == "d2" ){
    return new Derived2 ;
  } else {
    return 0 ;
  }
}

RCPP_MODULE(mod) {
  Rcpp::class_< Base >("Base")
    .factory<const std::string&>(newBase)
    .method("name", &Base::name)
  ;

}


/*** R
(dv1 <- new(Base, "d1"))
dv1$name()
(dv2 <- new(Base, "d2"))
dv2$name()
*/

输出：

> (dv1 <- new(Base, "d1"))
C++ object <0x1cd3e60> of class 'Base' <0x1ea3560>

> dv1$name()
[1] "Derived1"

> (dv2 <- new(Base, "d2"))
C++ object <0x1fbb9f0> of class 'Base' <0x1ea3560>

> dv2$name()
[1] "Derived2"

请注意，我添加了第二个派生类，删除了未使用的getNew方法，并重命名了factor方法。这种方式对我来说似乎更现实。

原始答案，现在可以作为替代选择：我担心您将不得不手工完成Rcpp模块提供的所有自动化操作，即生成R级别的类并使用工厂方法进行初始化。以下是对“ Rcpp模块”插图中的代码的改编以及Rcpp属性，以简化编码：

#include <Rcpp.h>
using namespace Rcpp;

// abstract class
class Base {
  public:
    virtual ~Base() {}
    virtual std::string name() const = 0;
    virtual Base* getNew() const = 0;
};

// derived class
class Derived1: public Base {
  public:
    Derived1() : Base() {}
    virtual std::string name() const { return "Derived1"; }
    virtual Derived1* getNew() const { return new Derived1(); };
};

// derived class
class Derived2: public Base {
  public:
    Derived2() : Base() {}
    virtual std::string name() const { return "Derived2"; }
    virtual Derived2* getNew() const { return new Derived2(); };
};

Base *newBase( const std::string &name ) {
  if ( name == "d1" ){
    return new Derived1 ;
  } else if ( name == "d2" ){
    return new Derived2 ;
  } else {
    return 0 ;
  }
}


//[[Rcpp::export]]
Rcpp::XPtr< Base > getNewBase(const std::string type) {
  return(Rcpp::XPtr< Base >(newBase(type)));
}

//[[Rcpp::export]]
std::string Base__name(Rcpp::XPtr< Base > ptr) {
  return ptr->name();
}


/*** R
setClass("Base", representation( pointer = "externalptr"))
Base_method <- function(name) {
  paste("Base", name, sep = "__")
}

setMethod("$", "Base", function(x, name) {
  function(...) do.call(Base_method(name), list(x@pointer, ...))
})

setMethod("initialize", "Base", function(.Object, ...) {
  .Object@pointer <- getNewBase(...)
  .Object
})

(dv <- new("Base", "d1"))
dv$name()
(dv <- new("Base", "d2"))
dv$name()
 */

有趣的输出：

> (dv <- new("Base", "d1"))
An object of class "Base"
Slot "pointer":
<pointer: 0x19b83e0>


> dv$name()
[1] "Derived1"

> (dv <- new("Base", "d2"))
An object of class "Base"
Slot "pointer":
<pointer: 0x1c02600>


> dv$name()
[1] "Derived2"

请注意，我使用的S4类这里，而RCPP_MODULE创建一个引用类。一个人可能也可以为此使用RC。这将是一个有趣的学习练习，因为到目前为止我还没有直接使用过RC。另外请注意，我用一个非常不同的XPtr比你。我不确定您要包装的内容。

如何使用Rcpp公开抽象类的指针？

1 个答案: