C++ 将Qt与STL和Boost混合使用-是否有任何桥梁可以让它变得简单？

有没有什么桥梁可以让Qt与STL和Boost的混合尽可能无缝和简单

---

这是对的后续行动，没有给出如何实现这一目标的具体答案。

到底是什么问题？
如果需要，可以忽略所有Qt集合类，并使用STL等价物。
类似地，您可以使用Boost的跨平台文件/网络库

---

使用Qt自己的主要原因可能是boost不一定广泛可用，尤其是在移动设备上。Boost的一些LIB比用于简单任务的Qt LIB要复杂一些。

一般来说，如果您坚持使用Qt集合类而不是us STL，那么使用Qt会更好。Qt、STL或Boost本身没有任何东西会妨碍彼此使用then

---

使用智能指针时必须小心，QT具有父/子关系，可以处理对象的销毁，在QT控制下释放对象会使您崩溃。

您需要什么桥

您可以将所有Qt容器类与std算法一起使用。 大多数时候，我更喜欢Qt容器类，因为我确信它们使用的是写时拷贝习惯用法（常量时间操作）。Qt的foreach函数创建容器的一个副本，这样您就可以确定它是一个常量时间操作

如果Qt信号槽机制变慢，您可以切换到升压替代方案。 Qt信号/插槽的优点在于两个线程之间的信号/插槽连接

QT与BOOST配合得很好。Lambda

---

对于“共享”的子-父关系，我使用这个helper函数

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 ) );
}

示例

#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;
}

#包括
#包括
#包括
#包括“iodevicestream.h”
int main（int argc，char*argv[]）
{
名称空间io=boost:：iostreams；
矢量数据；
QFile fl（“临时箱”）；
fl.open（QIODevice:：读写）；
io：：流输入输出（fl）；
std:：copy（data.begin（）、data.end（）、std:：ostream_迭代器（inoutput，“\n”）；
inoutput.flush（）；
inoutput.seekg（0，标准：：ios\U基：：beg）；
你到底在担心什么？理论上，boost和Qt不应该在很多地方需要共存。我还没有遇到任何问题，因为我刚刚开始了解Qt，但是Qt、STL和boost之间有这么多的重叠。我确信有很多地方需要某种编组。这就像用.NET和C++，这就是为什么M$想出了封送库。我正努力为我无法避免的事情做准备。首先，公司被称为微软，缩写MS只有13岁的脚本孩子称之为M$。第二，.NET/C++ +互操作是完全不同的野兽，因为你在完全不同的平台之间进行通信，管理。D和非托管代码。Qt和Boost都是C++库，在同一进程中运行，使用相同的运行时和所有的东西。那里不需要编组。@ JALF如果你不介意的话，我会继续使用我喜欢的缩写词。谢谢。Jalf：不仅仅是脚本小子：我也有这种罪恶感。删除QT对象是完全安全的。在QObject它将从其父对象的子列表中注销自身。完全没有崩溃。@Evan，底部有一些陷阱…我过去对此有过问题。这可能是由于上面文档中提到的排序问题。@Evan如果对象的父对象删除QObject，则不太安全，但a（不支持Qt）认为自己负责删除QObject的智能指针不知道QObject已从其下删除，因此稍后会尝试再次删除它…：（@JeremyFriesner:Qt的智能指针也有这个问题：@mgb这不是一个关于选择哪一个以及为什么的问题，而是关于同时使用这两个指针时应该做什么的问题。请参阅TimW的答案，这大致就是我所希望的。好的，我明白了，您可能想编辑这个问题来重新表述它。@mgb示例：我有一个AbstractImage基类必须实现加载（QIODevice*）函数。一个ImageXr子类，使用openEXR库加载EXR图像。但openEXR load使用istream作为输入，不知道Qt。@TimW这是迄今为止最好的答案……感谢现实世界的代码。了解Boost的流行程度，我希望Qt团队将这种桥作为框架的一部分，以避免人们重新发明w我认为，这也有助于在开发人员的工作中更快地采用QT。这可能是QT在某些C++领域中流行的一个非常重要的因素。不应该是“代码>方法= = IOSBASE：：BEG <代码> > <代码>查找<代码> SET>代码>下< /COD> >代码>偏移<代码>，而不是<代码> MyDealth.Posiy（）

？

namespace boost {

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

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;
}