Question

我正在创建一个自定义资源文件，但是当我设置虚拟数据并将其推送到容器堆栈时，数组中的值将变为null。我知道它为什么会发生（当包含块完成时数组数据被破坏），但我不知道如何防止它被破坏。

#pragma once


#include <vector>
#include <fstream>
#include <stdint.h>

#ifndef __RFNAME
#define __RFNAME "resource.dat"
#endif


using namespace std;

namespace rf {


    struct rfHEADER {
        uint32_t _versionNumber;
    };

    struct rfIMAGE {
        uint32_t _sizeOfData;
        uint32_t *_data;
    };

    struct rfSOUND {

    };

    class rfFILE {

    public:
        //Constructors
        rfFILE() 
        { 
            //Create a dummy header
            HEADER._versionNumber = 16;

            //Create a dummy image
            uint32_t imageArrData[] = {10, 52, 18, 1, 19, 20, 20, 10, 4, 10};
            rfIMAGE i;
            i._sizeOfData = 10;
            i._data = imageArrData;
            IMAGEDATA.push_back(i);

            //Does the data stay when the rfIMAGE data is pushed onto the vector?
            for(int j = 0; j < 10; j++)
            {
                printf("Test image data is: %d\n", IMAGEDATA.front()._data[j]);
            }

        }
        ~rfFILE() { }

        void test()
        {
            //Modify dummy data
            HEADER._versionNumber = 9;

            rfIMAGE i = IMAGEDATA.front();

            uint32_t imageArrData[] = {0};
            i._data = imageArrData;
            i._sizeOfData = 1;

            IMAGEDATA.front() = i;

        }

        void printVersionNumber() {
            printf("The current version number is... %d\n", HEADER._versionNumber);


            printf("The image data size is... %d\n", IMAGEDATA.front()._sizeOfData);
            printf("The image data is...\n");
            for(uint32_t i = 0; i < IMAGEDATA.front()._sizeOfData; i++)
            {
                printf("%d\t", IMAGEDATA.front()._data[i]);
            }

        }

        //Reads from a resource file
        void readFromFile()
        {
            //set the resource file name
            const char* filename = __RFNAME;

            //Set up the instream
            ifstream iStream;
            iStream.open(filename, ios_base::binary);

            //If the instream is open
            if(iStream.is_open()) {
                //Read the first 4 bytes into the header
                iStream.read((char*)&HEADER, sizeof(HEADER));




                //close the instream
                iStream.close();
            }

        }

        //Write to a resource file
        void writeToFile()
        {
            //set the resource file name that we will be writing to
            const char* fileName = __RFNAME;
            //Set up the outstream
            ofstream oStream;
            oStream.open(fileName, ios_base::binary);

            //if the stream is open
            if(oStream.is_open()) {

                //write the header
                oStream.write((char*)&HEADER, sizeof(HEADER));

                //Write how many elements are in the IMAGEDATA stack (4 bytes)
                oStream.write((char*)IMAGEDATA.size(), sizeof(IMAGEDATA.size()));
                //Loop through n times and write the image data, where n is the number of elements in IMAGEDATA
                for(int i = 0; i < IMAGEDATA.size(); i++) {
                    uint32_t datasize = IMAGEDATA[i]._sizeOfData;
                    oStream.write((char*)IMAGEDATA[i]._sizeOfData, sizeof(IMAGEDATA[i]._sizeOfData));
                    oStream.write((char*)IMAGEDATA[i]._data, datasize);
                }

                //Close the stream
                oStream.close();
            }



        }



    private:
        rfHEADER HEADER;
        vector<rfIMAGE> IMAGEDATA;
        vector<rfSOUND> SOUNDDATA;

    protected:
        rfFILE(const rfFILE& copy) { }
    };
}

关于如何将值放入虚拟rfIMAGE并在阻止虚拟数据在叶子范围内声明后推送到向量的任何想法？

Answer 1

您应该在构造函数中提供imageArrData虚拟为static函数的局部变量，否则一旦构造函数离开，数据就会超出范围：

//Constructors
rfFILE() { 
   //Create a dummy header
   HEADER._versionNumber = 16;

   //Create a dummy image
   static uint32_t imageArrData[] = {10, 52, 18, 1, 19, 20, 20, 10, 4, 10};
// ^^^^^^

<强>更新
另一个（更好的）选项是将整个图像数据保存在std::vector<uint32_t>中，而不是使用普通指针和大小，例如：

typedef std::vector<uint32_t> rfIMAGE;

要与原始uint32_t* data指针以及size_t size参数进行互动，您可以使用std::vector<>::assign()方法：

rfIMAGE image;

void setImage(uint32_t* imgData, size_t imgSize) {
    assert(imgData);
    image.assign(imgData,imgData + imgSize);
}

Answer 2

不是在堆栈上分配，而是尝试在堆上分配数据。当分配数据的代码块完成时，堆栈数据实际上已经消失。

替换此行：

uint32_t imageArrData[] = {10, 52, 18, 1, 19, 20, 20, 10, 4, 10};

使用以下内容，然后分配您的元素。

uint32_t* imageArrData = new uint32_t[10];
imageArrData[0] = 10;
imageArrData[1] = 52;
...

推入向量时数组数据不保存

2 个答案: