एसटीएल और बूस्ट के साथ मिक्सिंग क्यूटी - क्या इसे आसान बनाने के लिए कोई पुल हैं?

Question

एसटीएल और बूस्ट के साथ मिश्रित क्यूटी बनाने के लिए कोई पुल हैं जहां तक ​​संभव और सहज हो सके?

यह Mixing Qt and Boost पर एक फॉलोअप है, जहां इसे पूरा करने के लिए कोई विशिष्ट उत्तर नहीं दिया गया था।

Answer 1

आपको किन पुलों की आवश्यकता है?

आप सभी क्यूटी कंटेनर कक्षाओं का उपयोग std एल्गोरिदम के साथ कर सकते हैं। अधिकांश समय मैं क्यूटी कंटेनर कक्षाओं को पसंद करता हूं क्योंकि मुझे यकीन है कि वे कॉपी-ऑन-राइट मुहावरे (निरंतर समय ऑपरेशन) का उपयोग करते हैं। क्यूटी का foreach फ़ंक्शन कंटेनर की एक प्रति बनाता है, इसलिए यह अच्छा है कि आप निश्चित रूप से जानते हैं कि यह एक स्थिर समय ऑपरेशन है।

क्यूटी संकेत स्लॉट तंत्र धीमा करने के लिए आप को बढ़ावा देने विकल्प को बदल सकते हैं। क्यूटी सिग्नल/स्लॉट के बारे में बड़ी बात दो धागे के बीच सिग्नल/स्लॉट कनेक्शन है।

QtConcurrent BOOST.Lambda

---

साथ अच्छा काम करता है "साझा" बच्चों के माता पिता के संबंध में मैं इस सहायक समारोह का उपयोग करें।

template <class Object> 
static boost::shared_ptr<Object> makeSharedObject() 
{ 
    using namespace boost; 
    using namespace boost::lambda; 
    return boost::shared_ptr<Object>( 
     new Object(), 
     bind(&Object::deleteLater, _1)); 
} 

---

क्यूटी कंटेनरों Boost.serialize द्वारा समर्थित नहीं हैं, तो आप serialize कार्यों अपने आप को लिखने के लिए होगा। मुझे क्यूटी स्ट्रीमिंग कक्षाओं और Boost.archive के बीच एक पुल पसंद आएगा।

यहाँ मेरी QList क्रमबद्धता टेम्पलेट आप बाकी को यह पता लगाने कर सकते हैं ...

///\file document is based on "boost/serialization/list.hpp" 

namespace boost { 
    namespace serialization { 

     //--------------------------------------------------------------------------- 
     /// Saves a QList object to a collection 
     template<class Archive, class U > 
     inline void save(Archive &ar, const QList<U> &t, const uint /* file_version */) 
     { 
      boost::serialization::stl::save_collection< Archive, QList<U> >(ar, t); 
     } 

     //--------------------------------------------------------------------------- 
     /// Loads a QList object from a collection 
     template<class Archive, class U> 
     inline void load(Archive &ar, QList<U > &t, const uint /* file_version */) 
     { 
       boost::serialization::stl::load_collection< 
        Archive, 
        QList<U>, 
        boost::serialization::stl::archive_input_seq<Archive, QList<U> >, 
        boost::serialization::stl::no_reserve_imp< QList<U> > >(ar, t); 
     } 

     //--------------------------------------------------------------------------- 
     /// split non-intrusive serialization function member into separate 
     /// non intrusive save/load member functions 
     template<class Archive, class U > 
     inline void serialize(Archive &ar, QList<U> &t, const uint file_version) 
     { 
      boost::serialization::split_free(ar, t, file_version); 
     } 

    } // namespace serialization 
} // namespace boost 

BOOST_SERIALIZATION_COLLECTION_TRAITS(QList) 

---

आप को बढ़ावा चाहते हैं है।

namespace boost { 

    template<typename T> T * get_pointer(QPointer<T> const& qPointer) 
    { 
     return qPointer; 
    } 
} 

---

QIODevice का उपयोग करना है, जहां एक std::stream की जरूरत है

namespace boost { 
    namespace iostreams { 

     class IoDeviceSource 
     { 
     public: 
      typedef char char_type; 
      typedef source_tag category; 

      explicit IoDeviceSource(QIODevice& source) 
       : m_source(source) 
      { 
      } 

      std::streamsize read(char* buffer, std::streamsize n) 
      { 
       return return m_source.read(buffer, n); 
      } 
     private: 
      QIODevice& m_source; 
     }; 

     class IoDeviceSink { 

     public: 
      typedef char char_type; 
      typedef sink_tag category; 

      explicit IoDeviceSink(QIODevice& sink) 
       : m_sink(sink) 
      { 
      } 

      std::streamsize write(const char_type* buffer, std::streamsize n) 
      { 
       return m_sink.write(buffer, n); 
      } 

     private: 
      QIODevice &m_sink; 
     }; 

     class IoDeviceDevice { 

     public: 
      typedef char char_type; 
      typedef seekable_device_tag category; 

      explicit IoDeviceDevice(QIODevice& device) 
       :m_device(device) { 
      } 

      std::streamsize write(const char_type *buffer, std::streamsize n) 
      { 
       return m_device.write(buffer, n); 
      } 

      std::streamsize read(char* buffer, std::streamsize n) 
      { 
       return m_device.read(buffer, n); 
      } 

      stream_offset seek(stream_offset off, std::ios_base::seekdir way) 
      { 
       using namespace std; 
       stream_offset next(0); 

       if(way==ios_base::beg) 
       { 
        next = m_device.pos(); 
       } 
       else if(way==ios_base::cur) 
       { 
        next = m_device.pos() + offset; 
       } 
       else if(way==ios_base::end) 
       { 
        next = m_device.size() -1 + offset; 
       } 
       else 
       { 
        throw ios_base::failure("bad seek direction"); 
       } 

       if(!m_device.seek(next)) 
       { 
        throw ios_base::failure("bad seek offset"); 
       } 
       return m_device.pos(); 
      } 

     private:  
      QIODevice &m_device; 
     }; 
    } 
} 

उदाहरण

#include <iostream> 
#include <QFile> 
#include <boost/iostreams/stream.hpp> 
#include "iodevicestream.h" 

int main(int argc, char *argv[]) 
{ 
    namespace io = boost::iostreams; 

    QVector<int> data; 

    QFile fl("temp.bin"); 
    fl.open(QIODevice::ReadWrite); 
    io::stream<io::IoDeviceDevice> inoutput(fl); 

    std::copy(data.begin(), data.end(), std::ostream_iterator<int>(inoutput, "\n")); 
    inoutput.flush(); 
    inoutput.seekg(0, std::ios_base::beg); 
    std::cout << inoutput; 
    return 0; 
} 

Answer 2

समस्या क्या है?
यदि आप चाहते हैं और एसटीएल समकक्षों का उपयोग करते हैं तो आप सभी क्यूटी संग्रह कक्षाओं को अनदेखा कर सकते हैं।
इसी प्रकार आप बूस्ट की क्रॉस प्लेटफ़ॉर्म फ़ाइल/नेटवर्क libs का उपयोग कर सकते हैं।

मुख्य कारण क्यूटी के स्वयं के उपयोग करने के लिए शायद उस बढ़ावा जरूरी नहीं है कि व्यापक रूप से उपलब्ध विशेष रूप से मोबाइल उपकरणों पर। बूस्ट के कुछ काम सरल कार्यों के लिए क्यूटी लोगों की तुलना में थोड़ा अधिक जटिल हैं।

Answer 3

सामान्यतः आप क्यूटी का उपयोग करते समय बेहतर किराया देने जा रहे हैं यदि आप हमारे बजाय एसटीएल के बजाय क्यूटी संग्रह कक्षाओं में रहते हैं। क्यूटी, एसटीएल या बूस्ट में प्रति सीई नहीं है जो एक दूसरे के भीतर उपयोग करने से रोक देगा।

स्मार्ट पॉइंटर्स का उपयोग करते समय आपको सावधान रहना होगा क्यूटी के माता-पिता/बच्चे के रिश्ते हैं जो ऑब्जेक्ट्स के विनाश का ख्याल रख सकते हैं, क्यूटी के नियंत्रण में ऑब्जेक्ट्स को डिलीकेट करने से आपको दुर्घटना हो जाएगी।