एक बूस्ट सी ++ फीनिक्स अभिव्यक्ति वृक्ष को बदलना

Question

बूस्ट फीनिक्स लेख में, "अभिव्यक्ति वृक्ष को बदलना", here, कस्टम invert_actions वर्ग की विशेषज्ञता का एक सेट, बाइनरी अंकगणितीय अभिव्यक्तियों को उलटा करने के लिए उपयोग किया जाता है। उदाहरण के लिए a+ba-b बन जाता है; a*ba/b बन जाता है; और दोनों के लिए इसके विपरीत।

इसमें अभिव्यक्ति वृक्ष का एक पुनरावर्ती ट्रैवर्सल शामिल है - हालांकि, यह ट्रैवर्सल बंद हो जाता है जब ऑपरेटर को शामिल करने वाली अभिव्यक्ति को स्पष्ट रूप से संभाला नहीं जाता है। उदाहरण के लिए, _1+_2-_3_1-_2+_3 बन जाएगा, लेकिन _1+_1&_2 इस तरह रहेगा (& के लिए कोई हैंडलर नहीं है)। let(_a = 1, _b = 2) [ _a+_b ] भी अपरिवर्तित छोड़ा जाएगा।

मैंने सोचा था कि यह लेख के अनुसार था, लेकिन अंत में सूचीबद्ध परीक्षणों को देखते हुए, मुझे लगता है कि if_(_1 * _4)[_2 - _3] बदलने की उम्मीद है; प्रदान किए गए कोड के साथ (here), मुझे लगता है कि यह नहीं है।

मैं एक सामान्य बूस्ट फीनिक्स अभिव्यक्ति पेड़ को बदलने स्पष्ट रूप से सूचीबद्ध (एन-ary) ऑपरेटरों का एक सेट के सभी पर लागू होता है जो कैसे तो परिभाषित कर सकते हैं; दूसरों को अपरिवर्तित छोड़कर?

कुछ कोड उपयोगी हो सकते हैं। मुझे 0 आउटपुट करने के लिए निम्न C++ 11 कोड (ऑटो) चाहिए, और 2 नहीं; बिना &, या किसी अन्य ऑपरेटर/कथन को स्पष्ट रूप से संभालने।

#include <iostream> 
#include <boost/phoenix.hpp> 
#include <boost/proto/proto.hpp> 

using namespace boost; 
using namespace proto; 
using namespace phoenix; 
using namespace arg_names; 

struct invrt { 
    template <typename Rule> struct when : proto::_ {}; 
}; 

template <> 
struct invrt::when<rule::plus> 
    : proto::call< 
    proto::functional::make_expr<proto::tag::minus>(
     evaluator(_left, _context), evaluator(_right, _context) 
    ) 
    > 
{}; 

int main(int argc, char *argv[]) 
{ 
    auto f = phoenix::eval(_1+_1&_2 , make_context(make_env(), invrt())); 
    std::cout << f(1,2) << std::endl; // Alas 2 instead of 0 
    return 0; 
} 

Answer 1

इस तरह आप यह सीधे आद्य के साथ क्या है:

#include <iostream> 
#include <boost/phoenix.hpp> 
#include <boost/proto/proto.hpp> 
namespace proto = boost::proto; 
using namespace boost::phoenix; 
using namespace arg_names; 

struct invrt: 
    proto::or_< 
    proto::when< 
     // Turn plus nodes into minus 
     proto::plus<proto::_, proto::_>, 
     proto::functional::make_expr<proto::tag::minus>(
     invrt(proto::_left), invrt(proto::_right) 
    ) 
    >, 
    proto::otherwise< 
     // This recurses on children, transforming them with invrt 
     proto::nary_expr<proto::_, proto::vararg<invrt> > 
    > 
    > 
{}; 

int main(int argc, char *argv[]) 
{ 
    auto f = invrt()(_1+_1&_2); 
    proto::display_expr(f); 
    std::cout << f(1,2) << std::endl; 
    return 0; 
} 

फीनिक्स आद्य की चोटी पर सामान का एक गुच्छा स्तरित गया है। मुझे pheonix::eval की अर्थशास्त्र नहीं पता है या आपने जो भी प्रयास किया वह काम नहीं करता है। संभवतः किसी ने फीनिक्स के जानकार झंकार जाएगा।

==== संपादित करें ====

मैं फीनिक्स उदाहरण के साथ समस्या यह पता लगा। यह गैर-प्लस मामले के लिए रिकर्सिंग नहीं कर रहा है।

#include <iostream> 
#include <boost/phoenix.hpp> 
#include <boost/proto/proto.hpp> 

using namespace boost; 
using namespace proto; 
using namespace phoenix; 
using namespace arg_names; 

struct invrt { 
    template <typename Rule> 
    struct when : 
    // NOTE!!! recursively transform children and reassemble 
    nary_expr<_, vararg<proto::when<_, evaluator(_, _context)> > > 
    {}; 
}; 

template <> 
struct invrt::when<rule::plus> : 
    proto::call< 
    proto::functional::make_expr<proto::tag::minus>(
     evaluator(_left, _context), evaluator(_right, _context) 
    ) 
    > 
{}; 

int main() 
{ 
    auto f = phoenix::eval(_1+_1&_2 , make_context(make_env(), invrt())); 
    display_expr(f); 
    std::cout << f(1,2) << std::endl; // Prints 0. Huzzah! 
} 

आप समझते हैं चाहे सरल या सीधे आद्य समाधान की तुलना में अधिक जटिल आप तय करने के लिए है कि: अपने कोड इस प्रकार होना चाहिए।