Bugs do happen. You could have found a corner case. Few people may have
pushed the const variants around.
So with that we would appreciate it if you poked around a bit more and maybe
created an actual replicable bug report with a small self-contained example.
Thank you for your reply. Is there a specific bug tracking site for
Rcpp? Meanwhile, I will post an example here. The following C++ code
defines two classes, A and B. Their constructors take a vector and print
it to the terminal. 'A' works with a const reference, 'B' takes the
argument by value.
--------------
C++ Code
--------------
#include <Rcpp.h>
using namespace Rcpp;
class A {
public:
A(const Rcpp::NumericVector& v) {
for (int i=0; i<v.size(); ++i) {
std::cout << v[i] << std::endl;
}
}
void foo(const Rcpp::NumericVector& v) {
for (int i=0; i<v.size(); ++i) {
std::cout << v[i] << std::endl;
}
}
};
class B {
public:
B(Rcpp::NumericVector v) {
for (int i=0; i<v.size(); ++i) {
std::cout << v[i] << std::endl;
}
}
};
RCPP_MODULE(TestMod) {
class_<A>( "A" )
.constructor<const Rcpp::NumericVector&>("Constructor A.")
.method("foo", &A::foo, "Print a vector.")
;
class_<B>( "B" )
.constructor<Rcpp::NumericVector>("Constructor B.")
;
}
------------
Loading the library and using the module in R yields the following:
------------
R session
------------
> a <- new(A, c(1,2,3))
4.68671e-318
> a$foo(c(1,2,3))
1
2
3
> b <- new(B, c(1,2,3))
1
2
3
-------------
Note that for the constructor of 'A', not even the size of the vector is
interpreted correctly. This may randomly lead to segfaults. The methods
A::foo() and B::B(), however, work as expected.
Also, a personal note if I may: I think of classes like Rcpp::NumericVector
more as 'facilitators': they make it very easy to get R data structures (in
SEXP) 'down' to C++ to do work on them, and back again. When I want to do
more work in C++ itself, I prefer to use actual C++ data structures and would
use Rcpp::NumericVector to instantiate, say, a std::vector<double> which
other C++ classes can access. If I am doing 'matrix math', the Armadillo
classes work well; for general C++ work the STL is trusted.
This is a very interesting topic. In fact, most of my code relies on STL
containers directly. The class exposed to R is actually a facade for a
pure virtual C++ class. Only within this facade, I use
Rcpp::NumericVector. Many of the functions in the remaining code take
iterator ranges. Thus, I can operate on Rcpp vectors or STL vectors
without copying.
Using const references in the exposed classes is not essential for my
program. I did it out of a habit. I am worried about the fact that it
compiles without error and yields somewhat undefined behaviour, though.
Best regards,
Peter