opérateur = dans Boost :: Python

Question

Si j'ai quelque chose comme la classe suivante

class Foo 
{ 
private: 
    int _bar; 
public: 
    Foo& operator=(const Foo& other) 
    { 
     _bar = other._bar; 
     return *this; 
    } 
} 

est-il un moyen facile d'exporter cette fonctionnalité à python en utilisant boost :: python? La documentation ne répertorie pas et agréable et facile

.def(self = self) 

Je ne suis pas un expert en python, donc je ne sais même pas si cela est nécessaire pour être honnête. Mais je veux cette fonctionnalité dans mes scripts python, donc je poste la question juste pour m'assurer.

Edit:

ici sont les erreurs du compilateur quand je fais faire def (auto = auto)

.\src\Python.cpp(12) : error C2780: 'boost::python::class_<W> &boost::python::class_<W>::def(const char *,Fn,const A1 &,const A2 &,const A3 &)' : expects 5 arguments - 1 provided 
     with 
     [ 
      W=Foo 
     ] 
     depends\common\include\boost/python/class.hpp(265) : see declaration of 'boost::python::class_<W>::def' 
     with 
     [ 
      W=Foo 
     ] 
.\src\Python.cpp(12) : error C2780: 'boost::python::class_<W> &boost::python::class_<W>::def(const char *,Fn,const A1 &,const A2 &)' : expects 4 arguments - 1 provided 
     with 
     [ 
      W=Foo 
     ] 
     depends\common\include\boost/python/class.hpp(249) : see declaration of 'boost::python::class_<W>::def' 
     with 
     [ 
      W=Foo 
     ] 
.\src\Python.cpp(12) : error C2780: 'boost::python::class_<W> &boost::python::class_<W>::def(const char *,A1,const A2 &)' : expects 3 arguments - 1 provided 
     with 
     [ 
      W=Foo 
     ] 
     depends\common\include\boost/python/class.hpp(242) : see declaration of 'boost::python::class_<W>::def' 
     with 
     [ 
      W=Foo 
     ] 
.\src\Python.cpp(12) : error C2780: 'boost::python::class_<W> &boost::python::class_<W>::def(const char *,F)' : expects 2 arguments - 1 provided 
     with 
     [ 
      W=Foo 
     ] 
     depends\common\include\boost/python/class.hpp(233) : see declaration of 'boost::python::class_<W>::def' 
     with 
     [ 
      W=Foo 
     ] 
.\src\Python.cpp(12) : error C2784: 'boost::python::class_<W> &boost::python::class_<W>::def(const boost::python::def_visitor<Derived> &)' : could not deduce template argument for 'const boost::python::def_visitor<Derived> &' from 'boost::python::self_ns::self_t' 
     with 
     [ 
      W=Foo 
     ] 
     depends\common\include\boost/python/class.hpp(223) : see declaration of 'boost::python::class_<W>::def' 
     with 
     [ 
      W=Foo 
     ] 

Answer 1

Je ne suis pas un expert en Python, mais en python avec l'opérateur afféterie " = "n'a pas la même signification qu'en C++: a=b crée une nouvelle référence au même objet interne, donc il ne sert à rien d'exporter le operator= de C++ dans l'interface python.
Ce que vous pouvez faire est de créer une fonction membre "clone" (implémentée en termes de operator=) qui retournera une copie de l'objet. Et importez cette fonction dans Python.
Sinon, en Python, vous pouvez utiliser un constructeur de copie: foo2 = Foo(foo1) (bien sûr ce constructeur doit être défini dans le c Interface ++/Python)

Answer 2

Vous ne devriez pas besoin d'exposer votre opérateur d'affectation à python. En python, l'opérateur d'affectation ne réattribue pas un objet existant en tant que copie d'un autre, il réattribue le nom à un objet différent. En python, vous créez un nouvel objet ou créez un nouvel objet copy of another one, qui ressemble plus à un constructeur de copie.

Si pour une raison quelconque, vous devez appeler l'opérateur d'affectation C de de python, vous pouvez probablement (ont pas essayé moi-même) ajouter une fonction de membre à faire comme ceci:

.def("reassign", &Foo::operator=); 

alors vous invoquer manuellement en python:

f1 = Foo() 
f2 = Foo() 
f2.reassign(f1) 

Answer 3

La réponse précédente à l'aide Foo::operator= ne fonctionne pas directement. Pour ce faire, à la place:

void assignFoo(Foo& self, const Foo& other) 
{ 
    self = other; 
} 

class_<Foo>("Foo") 
    .def("assign", assignFoo); 

Utilisation dans python:

foo, other = Foo(), Foo() 
foo.assign(other)