[Rcpp-devel] Module with vector of a class with inheritance, how to avoid slicing

Thu, Apr 4, 2013 9:10 AM

but when I do 

res=new("Rcpp_vector_Of_father",1:10)
res[[1]]$WhoAmI()
res[[0]]$WhoAmI()

rm(res)
gc()

that crashes with gc()
R.



----- Mail original -----
De: "Robin Girard" <robin.girard at mines-paristech.fr>
?: "Romain Francois" <romain at r-enthusiasts.com>
Cc: rcpp-devel at lists.r-forge.r-project.org
Envoy?: Jeudi 4 Avril 2013 18:08:50
Objet: Re: [Rcpp-devel] Module with vector of a class with inheritance, how to avoid slicing

that works.... indeed :)
R.


----- Mail original -----
De: "Romain Francois" <romain at r-enthusiasts.com>
?: "Robin Girard" <robin.girard at mines-paristech.fr>
Cc: rcpp-devel at lists.r-forge.r-project.org
Envoy?: Jeudi 4 Avril 2013 17:58:42
Objet: Re: [Rcpp-devel] Module with vector of a class with inheritance, how to avoid slicing

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" <romain at r-enthusiasts.com>
?: rcpp-devel at lists.r-forge.r-project.org
Cc: "Robin Girard" <robin.girard at 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.girard at 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 at lists.r-forge.r-project.org
https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel

[Rcpp-devel] Module with vector of a class with inheritance, how to avoid slicing

Thread (14 messages)