C++ HDF5重新缩放数据集最大维度

我已经创建了一个具有分块布局的数据集，我已经确定了数据集的最大大小

DataSpace *dataspace = new DataSpace (2, dims, maxdims)//maxdims equal to dims
// Modify dataset creation property to enable chunking
DSetCreatPropList prop;
prop.setChunk(2, chunk_dims);

然后我在里面记录了一些数据。最近我需要调整这个数据集的大小，但是新的大小超过了我在开始时确定的最大大小，这会导致每次我尝试调整数据集大小时出现异常

dataset->extend(new_size); //New size 

是否有一种方法可以扩展数据集的最大维度而不丢失记录的数据。如果没有，是否有办法用另一个包含我的数据且具有新的最大大小的数据集覆盖数据集？

选项：：extend（）仅适用于可扩展数据集（）

如果数据集是以最大大小创建的，则不能将其更改为可扩展数据集。您必须将内容复制到创建为无限的新数据集

这里有一个来自hdf网站（）的示例

/*
*此示例演示如何使用可扩展数据集。
*在当前版本的库中，数据集必须为
*大块的。
*/
#ifdef旧头文件名
#包括
#否则
#包括
#恩迪夫
#包括
#ifndef H5\u无\u名称空间
#ifndef H5\u无标准
使用std：：cout；
使用std：：endl；
#endif//H5\u无标准
#恩迪夫
#包括“H5Cpp.h”
#ifndef H5\u无\u名称空间
使用名称空间H5；
#恩迪夫
常量H5std_字符串文件名（“SDSextendible.h5”）；
常量H5std_字符串数据集_名称（“ExtendibleArray”）；
常数int NX=10；
常数int NY=5；
常数int秩=2；
内部主（空）
{
//Try块检测由其内部的任何调用引发的异常
尝试
{
/*
*发生故障时，请关闭自动打印，以便
*适当地处理错误
*/
异常：：dontPrint（）；
//创建具有无限维度的数据空间。
hsize_t dims[2]={3,3}；//创建时的数据集维度
hsize_t maxdims[2]={H5S_UNLIMITED，H5S_UNLIMITED}；
数据空间mspace1（秩、dims、maxdims）；
//创建新文件。如果文件存在，其内容将被覆盖。
H5文件（文件名，H5F附件）；
//修改数据集创建属性，即启用分块。
dsetproplistcparms；
hsize_t chunk_dims[2]={2,5}；
设置块（秩、块大小）；
//设置数据集的填充值
int fill_val=0；
setFillValue（PredType:：NATIVE\u INT和fill\u val）；
//使用cparms创建属性在文件中创建新数据集。
DataSet DataSet=file.createDataSet（DataSet_名称，PredType:：NATIVE_INT，mspace1，cparms）；
//扩展数据集。此调用确保数据集至少为3 x 3。
希泽特尺寸[2]；
大小[0]=3；
尺寸[1]=3；
扩展（大小）；
//选择一个超级实验室。
DataSpace fspace1=dataset.getSpace（）；
西泽t偏移量[2]；
偏移量[0]=0；
偏移量[1]=0；
hsize_t dims1[2]={3,3}；/*data1维*/
fspace1.选择Hyperslab（H5S\u选择集，dims1，偏移）；
//将数据写入hyperslab。
int data1[3][3]={{1,1,1}，/*要写入的数据*/
{1, 1, 1},
{1, 1, 1} };
write（data1，PredType:：NATIVE_INT，mspace1，fspace1）；
//扩展数据集。数据集变为10 x 3。
hsize_t dims2[2]={7，1}；/*数据2维*/
dims[0]=dims1[0]+dims2[0]；
尺寸[0]=尺寸[0]；
尺寸[1]=尺寸[1]；
扩展（大小）；
//选择一个超级实验室。
DataSpace fspace2=dataset.getSpace（）；
偏移量[0]=3；
偏移量[1]=0；
fspace2.选择Hyperslab（H5S\u选择集，dims2，偏移）；
//定义内存空间
数据空间mspace2（排名，dims2）；
//将数据写入hyperslab。
int data2[7]={2,2,2,2,2,2}；
write（data2，PredType:：NATIVE_INT，mspace2，fspace2）；
//扩展数据集。数据集变为10 x 5。
hsize_t dims3[2]={2，2}；/*数据3维*/
dims[1]=dims1[1]+dims3[1]；
尺寸[0]=尺寸[0]；
尺寸[1]=尺寸[1]；
扩展（大小）；
//选择一个超实验室
DataSpace fspace3=dataset.getSpace（）；
偏移量[0]=0；
偏移量[1]=3；
fspace3.选择Hyperslab（H5S\u选择集，dims3，偏移）；
//定义内存空间。
数据空间mspace3（排名，dims3）；
//将数据写入hyperslab。
int data3[2][2]={{3,3}，{3,3}；
write（data3，PredType:：NATIVE_INT，mspace3，fspace3）；
//从该数据集中读取数据并显示它。
int i，j；
int data_out[NX][NY]；
对于（i=0；i
如果您的数据集是以最大大小创建的，则无法将其更改为可扩展数据集。您必须将内容复制到以无限大小创建的新数据集

这里有一个来自hdf网站（）的示例

/*
*此示例演示如何使用可扩展数据集。
*在当前版本的库中，数据集必须为
*大块的。
*/
#ifdef旧头文件名
#包括
#否则
#包括
#恩迪夫
#包括
#ifndef H5\u无\u名称空间
#ifndef H5\u无标准
使用std：：cout；
使用std：：endl；
#endif//H5\u无标准
#恩迪夫
#包括“H5Cpp.h”
#ifndef H5_无名称PAC
/*
 *   This example shows how to work with extendible dataset.
 *   In the current version of the library dataset MUST be
 *   chunked.
 */
#ifdef OLD_HEADER_FILENAME
#include <iostream.h>
#else
#include <iostream>
#endif
#include <string>
#ifndef H5_NO_NAMESPACE
#ifndef H5_NO_STD
    using std::cout;
    using std::endl;
#endif  // H5_NO_STD
#endif
#include "H5Cpp.h"
#ifndef H5_NO_NAMESPACE
    using namespace H5;
#endif
const H5std_string FILE_NAME( "SDSextendible.h5" );
const H5std_string DATASET_NAME( "ExtendibleArray" );
const int      NX = 10;
const int      NY = 5;
const int      RANK = 2;
int main (void)
{
   //Try block to detect exceptions raised by any of the calls inside it
   try
   {
      /*
       * Turn off the auto-printing when failure occurs so that we can
       * handle the errors appropriately
       */
      Exception::dontPrint();

      //Create the data space with unlimited dimensions.
      hsize_t      dims[2]  = { 3, 3};  // dataset dimensions at creation
      hsize_t      maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
      DataSpace mspace1( RANK, dims, maxdims);

      //Create a new file. If file exists its contents will be overwritten.
      H5File file( FILE_NAME, H5F_ACC_TRUNC );

      //Modify dataset creation properties, i.e. enable chunking.          
      DSetCreatPropList cparms;
      hsize_t      chunk_dims[2] ={2, 5};
      cparms.setChunk( RANK, chunk_dims );

      //Set fill value for the dataset          
      int fill_val = 0;
      cparms.setFillValue( PredType::NATIVE_INT, &fill_val);

      //Create a new dataset within the file using cparms creation properties.
      DataSet dataset = file.createDataSet( DATASET_NAME, PredType::NATIVE_INT, mspace1, cparms);

      //Extend the dataset. This call assures that dataset is at least 3 x 3.
      hsize_t      size[2];
      size[0]   = 3;
      size[1]   = 3;
      dataset.extend( size );

      //Select a hyperslab.
      DataSpace fspace1 = dataset.getSpace ();
      hsize_t     offset[2];
      offset[0] = 0;
      offset[1] = 0;
      hsize_t      dims1[2] = { 3, 3};            /* data1 dimensions */
      fspace1.selectHyperslab( H5S_SELECT_SET, dims1, offset );

      //Write the data to the hyperslab.          
      int       data1[3][3] = { {1, 1, 1},       /* data to write */
                {1, 1, 1},
                {1, 1, 1} };
      dataset.write( data1, PredType::NATIVE_INT, mspace1, fspace1 );

      //Extend the dataset. Dataset becomes 10 x 3.           
      hsize_t   dims2[2] = { 7, 1};            /* data2 dimensions */
      dims[0]   = dims1[0] + dims2[0];
      size[0]   = dims[0];
      size[1]   = dims[1];
      dataset.extend( size );

      //Select a hyperslab.         
      DataSpace fspace2 = dataset.getSpace ();
      offset[0] = 3;
      offset[1] = 0;
      fspace2.selectHyperslab( H5S_SELECT_SET, dims2, offset );

      //Define memory space
      DataSpace mspace2( RANK, dims2 );

      //Write the data to the hyperslab.
      int  data2[7]    = { 2, 2, 2, 2, 2, 2, 2};
      dataset.write( data2, PredType::NATIVE_INT, mspace2, fspace2 );

      //Extend the dataset. Dataset becomes 10 x 5.
      hsize_t   dims3[2] = { 2, 2};            /* data3 dimensions */
      dims[1]   = dims1[1] + dims3[1];
      size[0]   = dims[0];
      size[1]   = dims[1];
      dataset.extend( size );

      //Select a hyperslab          
      DataSpace fspace3 = dataset.getSpace ();
      offset[0] = 0;
      offset[1] = 3;
      fspace3.selectHyperslab( H5S_SELECT_SET, dims3, offset );

      //Define memory space.
      DataSpace mspace3( RANK, dims3 );

      //Write the data to the hyperslab.          
      int         data3[2][2] = { {3, 3}, {3, 3} };
      dataset.write( data3, PredType::NATIVE_INT, mspace3, fspace3 );

      //Read the data from this dataset and display it.          
      int i, j;
      int data_out[NX][NY];
      for (i = 0; i < NX; i++)
      {
         for (j = 0; j < NY; j++)
            data_out[i][j] = 0;
      }
      dataset.read( data_out, PredType::NATIVE_INT );
      /*
       * Resulting dataset
       *
       *     1 1 1 3 3
       *     1 1 1 3 3
       *     1 1 1 0 0
       *     2 0 0 0 0
       *     2 0 0 0 0
       *     2 0 0 0 0
       *     2 0 0 0 0
       *     2 0 0 0 0
       *     2 0 0 0 0
       *     2 0 0 0 0
       */

      //Display the result.          
      for (i=0; i < NX; i++)
      {
          for(j=0; j < NY; j++)
             cout << data_out[i][j] << "  ";
          cout << endl;
      }
   }  // end of try block
   // catch failure caused by the H5File operations
   catch( FileIException error )
   {
      error.printError();
      return -1;
   }
   // catch failure caused by the DataSet operations
   catch( DataSetIException error )
   {
      error.printError();
      return -1;
   }
   // catch failure caused by the DataSpace operations
   catch( DataSpaceIException error )
   {
      error.printError();
      return -1;
   }
   // catch failure caused by the DataSpace operations
   catch( DataTypeIException error )
   {
      error.printError();
      return -1;
   }
   return 0;
}