Правильний спосіб повернути вказівник на "новий" об'єкт з функції Rcpp

Розглянемо 1) спеціальний клас з потенційно великим друком пам’яті та 2) функцію верхнього рівня, яка виконує деяку попередню обробку, потім створює та повертає новий об’єкт нашого спеціального класу. Щоб уникнути зайвого копіювання за значенням, функція розподіляє об'єкт і повертає на нього вказівник.

Виходячи з попередньої дискусії , здається, що правильний спосіб повернути вказівник на новостворений об’єкт - це обернути його Rcpp::XPtr<>. Однак R потім розглядає це ефективно як externalptr, і я намагаюся знайти належний спосіб викласти це за допомогою сучасного RCPP_EXPOSED_CLASSі RCPP_MODULEспособу здійснення справ.

Альтернатива - повернути необроблений покажчик. Але тоді я не на 100% впевнений у тому, що пам'ять об'єкта правильно очищається. Я побіг valgrindперевірити на предмет витоку пам’яті, і його не знайшли. Однак хто займається прибиранням? R?

test.cpp

#include <Rcpp.h>

// Custom class
class Double {
public:
  Double( double v ) : value(v) {}
  double square() {return value*value;}
private:
  double value;
};

// Make the class visible
RCPP_EXPOSED_CLASS(Double)

// Option 1: returning raw pointer
Double* makeDouble( double x ) {
  Double* pd = new Double(x);
  return pd;
}

// Option 2: returning XPtr<>
SEXP makeDouble2( double x ) {
  Double* pd = new Double(x);
  Rcpp::XPtr<Double> ptr(pd);
  return ptr;
}

RCPP_MODULE(double_cpp) {
  using namespace Rcpp;

  function( "makeDouble", &makeDouble );
  function( "makeDouble2", &makeDouble2 );

  class_<Double>("Double")
    .constructor<double>("Wraps a double")
    .method("square", &Double::square, "square of value")
    ;
}

В Р

Rcpp::sourceCpp("test.cpp")
d1 <- makeDouble(5.4)     # <-- who cleans this up???
# C++ object <0x56257d628e70> of class 'Double' <0x56257c69cf90>
d1$square()
# 29.16

d2 <- makeDouble2(2.3)
# <pointer: 0x56257d3c3cd0>
d2$square()
# Error in d2$square : object of type 'externalptr' is not subsettable

Моє запитання полягає в тому, чи Rcpp::Xptr<>є правильним способом повернення покажчиків, і якщо так, то як я можу отримати R, щоб результат бачив як Double, ні externalptr? Крім того, якщо повернення необробленого покажчика не викликає проблем з пам'яттю, хто очищає об'єкт, який створює функція?

Я думаю, що є сенс дивитись на різні підходи окремо. Це робить розрізнення чіткішим. Зауважте, що це досить схоже на обговорення у віньетці модулів Rcpp.

Під час використання Rcpp::XPtrви маєте свій клас та надаєте експортовані функції C ++ для кожного методу, який ви хочете викрити:

#include <Rcpp.h>

// Custom class
class Double {
public:
    Double( double v ) : value(v) {}
    double square() {return value*value;}
private:
    double value;
};

// [[Rcpp::export]]
Rcpp::XPtr<Double> makeDouble(double x) {
    Double* pd = new Double(x);
    Rcpp::XPtr<Double> ptr(pd);
    return ptr;
}

// [[Rcpp::export]]
double squareDouble(Rcpp::XPtr<Double> x) {
    return x.get()->square();
}

/***R
(d2 <- makeDouble(5.4))
squareDouble(d2)
*/

Вихід:

> Rcpp::sourceCpp('59384221/xptr.cpp')

> (d2 <- makeDouble(5.4))
<pointer: 0x560366699b50>

> squareDouble(d2)
[1] 29.16

Зауважимо, що в R об'єктом є лише "покажчик". Ви можете додати клас S4 / RC / R6 / ... на стороні R, якщо хочете чогось приємного.

Встановлення зовнішнього вказівника в клас на стороні R - це те, що ви отримуєте безкоштовно, використовуючи модулі Rcpp:

#include <Rcpp.h>

// Custom class
class Double {
public:
    Double( double v ) : value(v) {}
    double square() {return value*value;}
private:
    double value;
};

RCPP_MODULE(double_cpp) {
    using namespace Rcpp;

    class_<Double>("Double")
        .constructor<double>("Wraps a double")
        .method("square", &Double::square, "square of value")
    ;
}

/***R
(d1 <- new(Double, 5.4))
d1$square()
*/

Вихід:

> Rcpp::sourceCpp('59384221/modules.cpp')

> (d1 <- new(Double, 5.4))
C++ object <0x560366452eb0> of class 'Double' <0x56036480f320>

> d1$square()
[1] 29.16

Також підтримується використання заводського методу замість конструктора на C ++, але з однаковим використанням на стороні R:

#include <Rcpp.h>

// Custom class
class Double {
public:
    Double( double v ) : value(v) {}
    double square() {return value*value;}
private:
    double value;
};

Double* makeDouble( double x ) {
    Double* pd = new Double(x);
    return pd;
}

RCPP_MODULE(double_cpp) {
    using namespace Rcpp;

    class_<Double>("Double")
        .factory<double>(makeDouble, "Wraps a double")
        .method("square", &Double::square, "square of value")
    ;
}

/***R
(d1 <- new(Double, 5.4))
d1$square()
*/

Вихід:

> Rcpp::sourceCpp('59384221/modules-factory.cpp')

> (d1 <- new(Double, 5.4))
C++ object <0x5603665aab80> of class 'Double' <0x5603666eaae0>

> d1$square()
[1] 29.16

Нарешті, це RCPP_EXPOSED_CLASSстане в нагоді, якщо ви хочете поєднати заводську функцію R з модулями Rcpp, оскільки це створює Rcpp::asі Rcpp::wrapрозширення, необхідні для передачі об'єктів вперед між R і C ++. functionФабрику можна експортувати за допомогою атрибутів Rcpp, що я вважаю більш природним:

#include <Rcpp.h>

// Custom class
class Double {
public:
    Double( double v ) : value(v) {}
    double square() {return value*value;}
private:
    double value;
};

// Make the class visible
RCPP_EXPOSED_CLASS(Double)

// [[Rcpp::export]]
Double makeDouble( double x ) {
    Double d(x);
    return d;
}

RCPP_MODULE(double_cpp) {
    using namespace Rcpp;

    class_<Double>("Double")
        .method("square", &Double::square, "square of value")
    ;
}

/***R
(d1 <- makeDouble(5.4))
d1$square()
*/

Вихід:

> Rcpp::sourceCpp('59384221/modules-expose.cpp')

> (d1 <- makeDouble(5.4))
C++ object <0x560366ebee10> of class 'Double' <0x560363d5f440>

> d1$square()
[1] 29.16

Щодо очищення: Обидва Rcpp::XPtrта модулі Rcpp реєструють фіналізатор за замовчуванням, який викликає деструктор об'єкта. Ви також можете додати спеціальний фіналізатор, якщо потрібно.

Мені важко дати рекомендацію щодо одного з цих підходів. Можливо, найкраще спробувати кожен з них на якомусь простому прикладі і подивитися, що вам здається більш природним.