Le 04/04/13 17:34, Robin Girard a écrit :
Thanks a lot Romain ! you're amazingly fast and furious (got my seatbelt). I'll
definitely buy the book.
That works on my example, I confirm (I had a side problem with using _t which I removed
but don't see where this comes from, my side for sure). Now I'm trying to implement it
on my "real world" case and I fear that memory management with this solution
might poses a small problems.
Continuing with our example assume the children class has a field "value_" of
type double
class children1 : public father
{
public:
double value_
~children1(){};
children1(){};
children1(double value) : value_(value){};
children1(children1 const & x){};
virtual void WhoAmI() const{
Rcout<<"son1"<<endl;
};
};
and one want to create a constructor (in the class vector_Of_father) for a huge
vector of children with a NumericVector as input (one value of the vector for
one children in the vector)
this will require a loop in c++ and my first try could have been
vector_Of_father(Rcpp::NumericVector vec) : MyfatherList_(vec.size())
{
Rcpp::NumericVector::iterator MyNumericVector_iterator=vec.begin();
int i=0;
while ( MyNumericVector_iterator!=vec.end())
{
children1 *tmp=Calloc(1,children1); //
tmp->value_=*MyNumericVector_iterator;
MyfatherList_[i]=tmp;
++MyNumericVector_iterator; i++;
}
};
and I would felt guilty not doing that:
~vector_Of_father()
{
std::vector<father*>::iterator it=MyfatherList_.begin();
while (it!=MyfatherList_.end()){
Free(*it);
++it;
}
};
but that would clearly be against the spirit of Rcpp, I know, and for sure I
would not dare to do that (OK, I admit, I tryed and this gave me a leak, (all I
deserve ?) )
is there a possibility to convert this into something less intrusive in term of
memory allocation ?
I know that's not a big problem since I can do the (big) loop in R... but loops
in R are like uses of Calloc with Rcpp no ? they are possible but if we can
avoid them ...
I would just use new and delete, and likely combine this with some STL
ness to make nicer looking code. Something like this perhaps:
children* new_children1( double x){
return new children1( x ) ;
}
vector_Of_father(Rcpp::NumericVector vec) : MyfatherList_(vec.size()){
std::transform( vec.begin(), vec.end(), MyfatherList_.begin(),
new_children ) ;
}
Same for the destructor:
template<typename T>
void deleter( T* ptr ){ delete ptr; }
~vector_Of_father() {
std::for_each( MyfatherList_.begin(), MyfatherList_.end(),
deleter<father> ) ;
};
Of course, with C++11 you could use lambdas instead of the new_children1
and deleter functions, but that's another story.
Now, this design implies that the vector_Of_father class is repsonsible
for the memory of its pointers. That's fine. But you need to keep this
in mind for when you do stuff with the class, e.g. when you assign an
element to the vector, make sure you delete the previous one, etc ...
Romain
----- Mail original -----
De: "Romain Francois" <rom...@r-enthusiasts.com>
À: rcpp-devel@lists.r-forge.r-project.org
Cc: "Robin Girard" <robin.gir...@mines-paristech.fr>
Envoyé: Mercredi 3 Avril 2013 22:12:48
Objet: Re: [Rcpp-devel] Module with vector of a class with inheritance, how to
avoid slicing
Hi,
Fasten your seatbelts.
First, the problem is definitely object slicing. The best resource I
know about to explain it is a chapter of Scott Meyers "Effective C++".
Robin, I would highly recommend that you get it. Specially considering
that you are willing to get your hands dirty.
Anyway, I would suggest that your MyfatherList_ is a vector of father
pointers:
std::vector<father*> MyfatherList_;
if you use any kind of object, even smart pointers, you'll get slicing.
Then, you need to have a virtual destructor on the father class and make
the WhoAmI methods virtual. This is how you do inheritance in C++.
class father
{
public:
virtual ~father(){};
father(){};
father(father const & x) {};
virtual void WhoAmI() const{
Rcout<<"father"<<endl;
};
};
class children1_t : public father
{
public:
~children1_t(){};
children1_t(){};
children1_t(children1_t const & x){};
virtual void WhoAmI() const{
Rcout<<"son1"<<endl;
};
};
This is very basic C++ inheritance stuff.
The vector class looks like this:
class vector_Of_father {
public:
std::vector<father*> MyfatherList_;
~vector_Of_father(){};
vector_Of_father() : MyfatherList_(){};
father* vec_get( int i) { return MyfatherList_.at(i); };
void WhoAmI(int i) const {
MyfatherList_[i]->WhoAmI();
};
int size(){ return(MyfatherList_.size()); };
void push_back(object<father> func){
MyfatherList_.push_back(func);
};
};
Some comments.
- As I said above, you are storing a vector of pointers.
- that makes the implementation of WhoAmI, size simple.
- for get_vec, you can just return a pointer to a father. We support this.
- for push_back, you need to use object<father>, that is just a
disguised pointer. just using father* would require declaring how to
handle it. We don't support this yet (for some definition of yet).
Anyway, you can just see object<T> as T*
Now the module code.
RCPP_MODULE(mod_example2){
class_<father>( "father" )
.constructor()
.method("WhoAmI",&father::WhoAmI)
;
class_<children1_t>( "children1_t" )
.derives<father>("father" )
.constructor()
;
class_<children2_t>( "children2_t" )
.derives<father>("father" )
.constructor()
;
class_<vector_Of_father>( "vector_Of_father")
.constructor()
.method( "size", &vector_Of_father::size)
.method( "WhoAmI",&vector_Of_father::WhoAmI )
.method( "push_back", &vector_Of_father::push_back )
.method("[[",&vector_Of_father::vec_get)
;
}
That's it. You don't need to redefine WhoAmI for children classes. The
.derives makes it for you.
And with this:
res <- new( vector_Of_father )
res$push_back(new( father ))
res$push_back(new( children1_t ))
res$push_back(new( children2_t ))
res$WhoAmI(2)
res$WhoAmI(1)
res$WhoAmI(0)
res[[2]]$WhoAmI()
res[[1]]$WhoAmI()
res[[0]]$WhoAmI()
I do get:
son2
son1
father
son2
son1
father
Here is the full code of the .cpp file:
#include <Rcpp.h>
using namespace std;
using namespace Rcpp;
class father ;
class children1_t;
class children2_t ;
class vector_Of_father;
RCPP_EXPOSED_CLASS(father)
RCPP_EXPOSED_CLASS(children1_t)
RCPP_EXPOSED_CLASS(children2_t)
RCPP_EXPOSED_CLASS(vector_Of_father)
class father
{
public:
virtual ~father(){};
father(){};
father(father const & x) {};
virtual void WhoAmI() const{
Rcout<<"father"<<endl;
};
};
class children1_t : public father
{
public:
~children1_t(){};
children1_t(){};
children1_t(children1_t const & x){};
virtual void WhoAmI() const{
Rcout<<"son1"<<endl;
};
};
class children2_t : public father
{
public:
~children2_t(){};
children2_t(){};
children2_t(children2_t const & x){};
virtual void WhoAmI() const{
Rcout<<"son2"<<endl;
};
};
class vector_Of_father {
public:
std::vector<father*> MyfatherList_;
~vector_Of_father(){};
vector_Of_father() : MyfatherList_(){};
father* vec_get( int i) { return MyfatherList_.at(i); };
void WhoAmI(int i) const {
MyfatherList_[i]->WhoAmI();
};
int size(){ return(MyfatherList_.size()); };
void push_back(object<father> func){
MyfatherList_.push_back(func);
};
};
RCPP_MODULE(mod_example2){
class_<father>( "father" )
.constructor()
.method("WhoAmI",&father::WhoAmI)
;
class_<children1_t>( "children1_t" )
.derives<father>("father" )
.constructor()
;
class_<children2_t>( "children2_t" )
.derives<father>("father" )
.constructor()
;
class_<vector_Of_father>( "vector_Of_father")
.constructor()
.method( "size", &vector_Of_father::size)
.method( "WhoAmI",&vector_Of_father::WhoAmI )
.method( "push_back", &vector_Of_father::push_back )
.method("[[",&vector_Of_father::vec_get)
;
}
Romain
Le 03/04/13 18:43, Robin Girard a écrit :
I am still working on my vector of a class father with inheritance (polymorphic
subclasses ?). I created an exemple below that works fine but I face the known problem of
"slicing" as named here :
http://stackoverflow.com/questions/10154977/c-vector-with-inheritance and fail to
implement the proposed solution.
I have 2 tried 2 things and ended up with 2 questions:
Question 1 - I tryed the solution proposed in the link with make_shared and
shared_ptr. I had to add PKG_CXXFLAGS=-g -std=c++0x since my MinGW compiler did
not find any -std=c++11. I got no compilation error but when I run the code it
slices my children class :
res=new("Rcpp_vector_Of_father")
res$push_back(new("Rcpp_father"))
res$push_back_children1_t(new("Rcpp_children1_t"))
res$WhoAmI(1)
father
res$WhoAmI(0)
father
res[[1]]$WhoAmI()
father
res[[0]]$WhoAmI()
father
Question 2 - I tryed a solution with XPtr (although I'm not sure how this
works) and got the following error at the module compilation
example_mod_consumption.cpp: In member function 'void
vector_Of_father::push_back_children1_t(children1_t)':
example_mod_consumption.cpp:80:53: error: no matching function for call to
'std::vector<Rcpp::XPtr<father> >::push_back(Rcpp::XPtr<children1_t>)'
XPtr<father> has no relationship with XPtr<children1_t>. They are
independant classes generated by the XPtr template class. They don't
know about the inheritance.
below are the code for the two approach and at the end the code of the module.
-------------------- Solution with XPtr
#include <Rcpp.h>
using namespace std;
using namespace Rcpp;
class father ;
class children1_t;
class children2_t ;
class vector_Of_father;
RCPP_EXPOSED_CLASS(father)
RCPP_EXPOSED_CLASS(children1_t)
RCPP_EXPOSED_CLASS(children2_t)
RCPP_EXPOSED_CLASS(vector_Of_father)
class father
{
public:
~father(){};
father(){};
father(father const & x) {};
void WhoAmI() const{
Rcout<<"father"<<endl;
};
};
class children1_t : public father
{
public:
~children1_t(){};
children1_t(){};
children1_t(children1_t const & x){};
void WhoAmI() const{
Rcout<<"son1"<<endl;
};
};
class children2_t : public father
{
public:
~children2_t(){};
children2_t(){};
children2_t(children2_t const & x){};
void WhoAmI() const{
Rcout<<"son2"<<endl;
};
};
class vector_Of_father {
public:
std::vector<XPtr<father> > MyfatherList_;
//std::vector<shared_ptr<father> > MyfatherList_;
~vector_Of_father(){};
vector_Of_father() : MyfatherList_(){};
father vec_get( int i) { return(*(MyfatherList_.at(i))); };
void WhoAmI(int i) const
{
MyfatherList_[i]->WhoAmI();
};
int size(){ return(MyfatherList_.size()); };
void push_back(father func){
MyfatherList_.push_back(XPtr<father>(&func));
};
void push_back_children1_t(children1_t func){
MyfatherList_.push_back(XPtr<children1_t>(&func));
};
};
-------------------- Solution with make_shared and shared_ptr
only the class vector_of_father is different also #include <memory> is added
after Rcpp.h include.
class vector_Of_father {
public:
std::vector<shared_ptr<father> > MyfatherList_;
~vector_Of_father(){};
vector_Of_father() : MyfatherList_(){};
father vec_get( int i) { return(*(MyfatherList_.at(i))); };
void WhoAmI(int i) const
{
MyfatherList_[i]->WhoAmI();
};
int size(){ return(MyfatherList_.size()); };
void push_back(father func){
MyfatherList_.push_back(make_shared<father>(func));
};
void push_back_children1_t(children1_t func){
MyfatherList_.push_back(make_shared<children1_t>(func));
};
};
-------------- the module code
RCPP_MODULE(mod_example2){
using namespace Rcpp;
class_<father>( "father" )
//constructors
.constructor()
.method("WhoAmI",&father::WhoAmI)
;
class_<children1_t>( "children1_t" )
.derives<father>("father" )
//constructors
.constructor()
.method("WhoAmI",&children1_t::WhoAmI)
;
class_<children2_t>( "children2_t" )
.derives<father>("father" )
//constructors
.constructor()
.method("WhoAmI",&children2_t::WhoAmI)
;
class_<vector_Of_father>( "vector_Of_father")
.constructor()
// .constructor<int>()
.method( "size", &vector_Of_father::size)
// .method("capacity", &cplfunctionvec::capacity,"Return size of allocated
storage capacity. Returns the size of the storage space currently allocated for the vector, expressed
in terms of elements.")
// .method( "max_size", &cplfunctionvec::max_size)
.method( "WhoAmI",&vector_Of_father::WhoAmI )
//.method( "test",&vector_Of_father::test )
.method( "push_back", &vector_Of_father::push_back )
.method("push_back_children1_t",&vector_Of_father::push_back_children1_t)
// .const_method( "at", &cplfunctionvec::at )
.method("[[",&vector_Of_father::vec_get)
// .method("[[<-",&vector_Of_father::vec_set)
;
}
Dr. Girard Robin
Chargé de Recherche
MINES-ParisTech / Département Energétique et Procédés / PERSEE / Groupe ERSEI
Centre Procédés, Energies Renouvelables et Systèmes Energétiques (PERSEE)
Center for Processes, Renewables Energies and Energy Systems
Renewable Energies & Smartgrids (ERSEI)
1 Rue Claude Daunesse - CS 10207 - F-06904 Sophia Antipolis Cedex
Tel: +33.4.93.67.89.64 (~99), Fax: +33.4.93.95.75.35
e-mail : robin.gir...@mines-paristech.fr
web page perso http://www.mines-paristech.fr/Services/Annuaire/&?id=8828
statoverflow : http://stats.stackexchange.com/users/223/robin-girard
web page centre PERSEE : http://www.cep.mines-paristech.fr/
linkedin : http://www.linkedin.com/profile/view?id=14907272&trk=tab_pro
--
Romain Francois
Professional R Enthusiast
+33(0) 6 28 91 30 30
R Graph Gallery: http://gallery.r-enthusiasts.com
blog: http://blog.r-enthusiasts.com
|- http://bit.ly/ZTFLDo : Simpler R help tooltips
`- http://bit.ly/YFsziW : R Help tooltips
_______________________________________________
Rcpp-devel mailing list
Rcpp-devel@lists.r-forge.r-project.org
https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel
