C++ “提高效率”；输入流错误“；在达到一定的文件大小之后

我正在使用Boost:：serialization读取/写入包含3d模型的文件

在文件达到一定大小（大约8-12kb+）后，每当我尝试读取该文件时，序列化都会引发“输入流错误”异常。它每次都工作正常，直到那时-例如，我可以读/写一个1kb的模型12次成功，然后在第13次和以后它会抛出异常

下面是要序列化/反序列化的代码：

    JonsPackagePtr ReadJonsPkg(const std::string& jonsPkgName)
    {
        std::ifstream jonsPkgStream(jonsPkgName.c_str(), std::fstream::binary || std::fstream::in);
        JonsPackagePtr pkg(new JonsPackage());   // "JonsPackagePtr" is a boost_shared_ptr typedef

        if (jonsPkgStream && jonsPkgStream.good() && jonsPkgStream.is_open())
        {
            boost::archive::binary_iarchive iar(jonsPkgStream);

            iar >> (*pkg.get());
        }

        return pkg;
    }

    bool WriteJonsPkg(const std::string& jonsPkgName, const JonsPackagePtr pkg)
    {
        std::ofstream outStream(jonsPkgName.c_str(), std::fstream::out | std::fstream::binary);
        bool ret = false;

        if (outStream.is_open())
        {
            boost::archive::binary_oarchive oar(outStream);
            oar << (*pkg.get());

            ret = true;
        }

        return ret;
    }

JonsPackagePtr ReadJonsPkg（const std:：string&jonsPkgName）
{
std:：ifstream jonsPkgStream（jonsPkgName.c_str（），std:：fstream:：binary | | std:：fstream:：in）；
JonsPackagePtr-pkg（new JonsPackage（））；/“JonsPackagePtr”是一个boost_-shared_-ptr-typedef
if（jonsPkgStream&&jonsPkgStream.good（）&&jonsPkgStream.is_open（））
{
boost:：archive:：binary_iarchive iar（jonsPkgStream）；
iar>>（*pkg.get（））；
}
返回包装；
}
bool WriteJonsPkg（const std:：string&jonsPkgName，const JonsPackagePtr pkg）
{
std:：of流外扩（jonsPkgName.c_str（），std:：fstream:：out | std:：fstream:：binary）；
bool-ret=假；
如果（超出流。是否打开（））
{
boost:：archive:：binary_oarchive oar（扩展）；
oar在
ReadJonsPkg
中，您应该使用按位或：
std:：fstream:：binary | std:：fstream:：in
在
ReadJonsPkg
中，您应该使用按位或：
std:：fstream:：binary | std:：fstream:：in
这可能不是问题，但在
ReadJonsPkg
中，您应该使用按位或：
std:：fstream:：binary | std：：fstream：：in
不是，这是问题所在。先生，您赢得了interwebz。回答后，我会很高兴标记并投票……我刚刚开始深入挖掘：）这可能不是问题所在，但在
ReadJonsPkg
中，您应该使用位或：
std：：fstream：：binary | std：：fstream：：in
不是问题所在。You先生，赢得interwebz。回答这个问题，我会很高兴地给它贴上标签并投票……我刚刚开始深入挖掘：）
/* PackageHeader definition */
    struct PackageHeader
    {
        std::string mSignature;
        uint8_t mMajorVersion;
        uint8_t mMinorVersion;


        PackageHeader();
    };

    /* PackageMesh definition */
    struct PackageMesh
    {
        std::vector<float> mVertexData;
        std::vector<uint32_t> mIndiceData;


        PackageMesh();
    };

    /* PackageModel definition */
    struct PackageModel
    {
        std::string mName;
        std::vector<PackageModel> mChildren;
        std::vector<PackageMesh> mMeshes;
        Mat4 mTransform;


        PackageModel();
    };

    /* JonsPackage definition */
    struct JonsPackage
    {
        PackageHeader mHeader;
        std::vector<PackageModel> mModels;


        JonsPackage();
    };


    typedef boost::shared_ptr<JonsPackage> JonsPackagePtr;
    JonsPackagePtr ReadJonsPkg(const std::string& jonsPkgName);
    bool WriteJonsPkg(const std::string& jonsPkgName, const JonsPackagePtr pkg);


    /* PackageHeader inlines */
    inline PackageHeader::PackageHeader() : mSignature("jons"), mMajorVersion(LatestMajorVersion), mMinorVersion(LatestMinorVersion)
    {
    }

    /* PackageModel inlines */
    inline PackageModel::PackageModel() : mName(""), mTransform(1.0f)
    {
    }

    /* PackageMesh inlines */
    inline PackageMesh::PackageMesh()
    {
    }

    /* JonsPackage inlines */
    inline JonsPackage::JonsPackage()
    {
    }

namespace boost
{
    namespace serialization
    {
        template<class Archive>
        void serialize(Archive & ar, JonsEngine::PackageHeader& header, const unsigned int version)
        {
            ar & header.mMajorVersion;
            ar & header.mMinorVersion;
            ar & header.mSignature;
        }

        template<class Archive>
        void serialize(Archive & ar, JonsEngine::PackageModel& model, const unsigned int version)
        {
            ar & model.mName;
            ar & model.mChildren;
            ar & model.mMeshes;
            ar & model.mTransform;
        }

        template<class Archive>
        void serialize(Archive & ar, JonsEngine::PackageMesh& mesh, const unsigned int version)
        {
            ar & mesh.mVertexData;
            ar & mesh.mIndiceData;
        }

        template<class Archive>
        void serialize(Archive & ar, JonsEngine::JonsPackage& pkg, const unsigned int version)
        {
            ar & pkg.mHeader;
            ar & pkg.mModels;
        }

        template<class Archive>
        void serialize(Archive & ar, glm::detail::tmat4x4<glm::mediump_float> transform, const unsigned int version)
        {
            ar & transform[0];
            ar & transform[1];
            ar & transform[2];
            ar & transform[3];
        }

        template<class Archive>
        void serialize(Archive & ar, glm::detail::tvec4<glm::mediump_float> vec, const unsigned int version)
        {
            ar & vec.x;
            ar & vec.y;
            ar & vec.z;
            ar & vec.w;
        }
    } // namespace serialization
} // namespace boost