给定一个字符串向量，将它们写入HDF5数据集的最佳方法是什么？目前我正在做类似以下的事情：
const unsigned int MaxStrLength = 512;
struct TempContainer {
char string[MaxStrLength];
};
void writeVector (hid_t group, std::vector<std::string> const & v)
{
//
// Firstly copy the contents of the vector into a temporary container
std::vector<TempContainer> tc;
for (std::vector<std::string>::const_iterator i = v.begin ()
, end = v.end ()
; i != end
; ++i)
{
TempContainer t;
strncpy (t.string, i->c_str (), MaxStrLength);
tc.push_back (t);
}
//
// Write the temporary container to a dataset
hsize_t dims[] = { tc.size () } ;
hid_t dataspace = H5Screate_simple(sizeof(dims)/sizeof(*dims)
, dims
, NULL);
hid_t strtype = H5Tcopy (H5T_C_S1);
H5Tset_size (strtype, MaxStrLength);
hid_t datatype = H5Tcreate (H5T_COMPOUND, sizeof (TempConainer));
H5Tinsert (datatype
, "string"
, HOFFSET(TempContainer, string)
, strtype);
hid_t dataset = H5Dcreate1 (group
, "files"
, datatype
, dataspace
, H5P_DEFAULT);
H5Dwrite (dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, &tc[0] );
H5Dclose (dataset);
H5Sclose (dataspace);
H5Tclose (strtype);
H5Tclose (datatype);
}
至少，我真的想改变上面的内容，以便：
我对如何存储数据没有限制，例如，如果有更好的方法，它不必是 COMPOUND 数据类型。
编辑：为了缩小问题范围，我对使用C ++方面的数据比较熟悉，这是我需要大部分帮助的HDF5方面。
感谢您的帮助。
答案 0 :(得分：10)
[非常感谢dirkgently帮助回答这个问题。]
要在HDF5中写入可变长度字符串，请使用以下命令：
// Create the datatype as follows
hid_t datatype = H5Tcopy (H5T_C_S1);
H5Tset_size (datatype, H5T_VARIABLE);
//
// Pass the string to be written to H5Dwrite
// using the address of the pointer!
const char * s = v.c_str ();
H5Dwrite (dataset
, datatype
, H5S_ALL
, H5S_ALL
, H5P_DEFAULT
, &s );
编写容器的一个解决方案是单独编写每个元素。这可以使用hyperslabs来实现。
例如：
class WriteString
{
public:
WriteString (hid_t dataset, hid_t datatype
, hid_t dataspace, hid_t memspace)
: m_dataset (dataset), m_datatype (datatype)
, m_dataspace (dataspace), m_memspace (memspace)
, m_pos () {}
private:
hid_t m_dataset;
hid_t m_datatype;
hid_t m_dataspace;
hid_t m_memspace;
int m_pos;
// ...
public:
void operator ()(std::vector<std::string>::value_type const & v)
{
// Select the file position, 1 record at position 'pos'
hsize_t count[] = { 1 } ;
hsize_t offset[] = { m_pos++ } ;
H5Sselect_hyperslab( m_dataspace
, H5S_SELECT_SET
, offset
, NULL
, count
, NULL );
const char * s = v.c_str ();
H5Dwrite (m_dataset
, m_datatype
, m_memspace
, m_dataspace
, H5P_DEFAULT
, &s );
}
};
// ...
void writeVector (hid_t group, std::vector<std::string> const & v)
{
hsize_t dims[] = { m_files.size () } ;
hid_t dataspace = H5Screate_simple(sizeof(dims)/sizeof(*dims)
, dims, NULL);
dims[0] = 1;
hid_t memspace = H5Screate_simple(sizeof(dims)/sizeof(*dims)
, dims, NULL);
hid_t datatype = H5Tcopy (H5T_C_S1);
H5Tset_size (datatype, H5T_VARIABLE);
hid_t dataset = H5Dcreate1 (group, "files", datatype
, dataspace, H5P_DEFAULT);
//
// Select the "memory" to be written out - just 1 record.
hsize_t offset[] = { 0 } ;
hsize_t count[] = { 1 } ;
H5Sselect_hyperslab( memspace, H5S_SELECT_SET, offset
, NULL, count, NULL );
std::for_each (v.begin ()
, v.end ()
, WriteStrings (dataset, datatype, dataspace, memspace));
H5Dclose (dataset);
H5Sclose (dataspace);
H5Sclose (memspace);
H5Tclose (datatype);
}
答案 1 :(得分：4)
以下是使用HDF5 c ++ API编写可变长度字符串向量的一些工作代码。
我在其他帖子中加入了一些建议：
string::c_str()获取指向字符串的指针vector的{{1}}并传递给HDF5 API 创建昂贵的字符串副本（例如char*）无需。 strdup()返回指向底层字符串的空终止数据的指针。这正是该功能的用途。当然，带有嵌入空值的字符串将不适用于此...
c_str()保证具有连续的底层存储，因此使用std::vector和vector与使用原始数组相同，但当然比笨重，旧的更加整洁和安全塑造了做事的方式。
vector::data()答案 2 :(得分：1)
如果您正在查看更清晰的代码：我建议您创建一个函数，它将获取一个字符串并将其保存到HDF5容器（以所需模式）。理查德，我使用了错误的算法，请重新检查！
std::for_each(v.begin(), v.end(), write_hdf5);
struct hdf5 : public std::unary_function<std::string, void> {
hdf5() : _dataset(...) {} // initialize the HDF5 db
~hdf5() : _dataset(...) {} // close the the HDF5 db
void operator(std::string& s) {
// append
// use s.c_str() ?
}
};
这有助于开始吗？
答案 3 :(得分：1)
我有一个类似的问题，但需要注意的是我想要一个存储为属性的字符串向量。属性的棘手之处在于我们不能使用像hyperslabs这样的花哨的数据空间特性（至少使用C ++ API）。
但是在任何一种情况下，将字符串向量输入数据集中的单个条目可能很有用（例如，如果您总是希望将它们一起读取）。在这种情况下，所有魔法都带有类型，而不是数据空间本身。
基本上有4个步骤：
vector<const char*>。hvl_t结构，指向该向量并包含它的长度。H5::VarLenType包裹（可变长度）H5::StrType。hvl_t类型写入数据集。 这种方法的一个非常好的部分是你将整个条目填入HDF5认为的标量值。这意味着将其作为属性（而不是数据集）是微不足道的。
您是选择此解决方案还是在其自己的数据集条目中包含每个字符串的解决方案可能也是所需性能的问题：如果您正在寻找对特定字符串的随机访问，那么它可能更好在数据集中写出字符串，以便将它们编入索引。如果您总是将它们全部读出来，那么这个解决方案也可以正常工作。
以下是使用C ++ API和简单标量数据集执行此操作的简短示例：
#include <vector>
#include <string>
#include "H5Cpp.h"
int main(int argc, char* argv[]) {
// Part 0: make up some data
std::vector<std::string> strings;
for (int iii = 0; iii < 10; iii++) {
strings.push_back("this is " + std::to_string(iii));
}
// Part 1: grab pointers to the chars
std::vector<const char*> chars;
for (const auto& str: strings) {
chars.push_back(str.data());
}
// Part 2: create the variable length type
hvl_t hdf_buffer;
hdf_buffer.p = chars.data();
hdf_buffer.len = chars.size();
// Part 3: create the type
auto s_type = H5::StrType(H5::PredType::C_S1, H5T_VARIABLE);
s_type.setCset(H5T_CSET_UTF8); // just for fun, you don't need this
auto svec_type = H5::VarLenType(&s_type);
// Part 4: write the output to a scalar dataset
H5::H5File out_file("vtest.h5", H5F_ACC_EXCL);
H5::DataSet dataset(
out_file.createDataSet("the_ds", svec_type, H5S_SCALAR));
dataset.write(&hdf_buffer, svec_type);
return 0;
}
答案 4 :(得分：0)
而不是TempContainer，你可以使用一个简单的std :: vector（你也可以将它模板化以匹配T - ＆gt; basic_string。 像这样：
#include <algorithm>
#include <vector>
#include <string>
#include <functional>
class StringToVector
: std::unary_function<std::vector<char>, std::string> {
public:
std::vector<char> operator()(const std::string &s) const {
// assumes you want a NUL-terminated string
const char* str = s.c_str();
std::size_t size = 1 + std::strlen(str);
// s.size() != strlen(s.c_str())
std::vector<char> buf(&str[0], &str[size]);
return buf;
}
};
void conv(const std::vector<std::string> &vi,
std::vector<std::vector<char> > &vo)
{
// assert vo.size() == vi.size()
std::transform(vi.begin(), vi.end(),
vo.begin(),
StringToVector());
}
答案 5 :(得分：0)
为了能够阅读 std::vector<std::string>我根据Leo的提示https://stackoverflow.com/a/15220532/364818发布我的解决方案。
我混合了C和C ++ API。请随意编辑它并使其更简单。
请注意，当您调用read时，HDF5 API会返回char*指针列表。这些char*指针必须在使用后释放，否则会发生内存泄漏。
用法示例
H5::Attribute Foo = file.openAttribute("Foo");
std::vector<std::string> foos
Foo >> foos;
这是代码
const H5::Attribute& operator>>(const H5::Attribute& attr0, std::vector<std::string>& array)
{
H5::Exception::dontPrint();
try
{
hid_t attr = attr0.getId();
hid_t atype = H5Aget_type(attr);
hid_t aspace = H5Aget_space(attr);
int rank = H5Sget_simple_extent_ndims(aspace);
if (rank != 1) throw PBException("Attribute " + attr0.getName() + " is not a string array");
hsize_t sdim[1];
herr_t ret = H5Sget_simple_extent_dims(aspace, sdim, NULL);
size_t size = H5Tget_size (atype);
if (size != sizeof(void*))
{
throw PBException("Internal inconsistency. Expected pointer size element");
}
// HDF5 only understands vector of char* :-(
std::vector<char*> arr_c_str(sdim[0]);
H5::StrType stringType(H5::PredType::C_S1, H5T_VARIABLE);
attr0.read(stringType, arr_c_str.data());
array.resize(sdim[0]);
for(int i=0;i<sdim[0];i++)
{
// std::cout << i << "=" << arr_c_str[i] << std::endl;
array[i] = arr_c_str[i];
free(arr_c_str[i]);
}
}
catch (H5::Exception& err)
{
throw std::runtime_error(string("HDF5 Error in " )
+ err.getFuncName()
+ ": "
+ err.getDetailMsg());
}
return attr0;
}
答案 6 :(得分：0)
我迟到了，但我根据有关段错误的评论修改了Leo Goodstadt的答案。我在linux上，但我没有这样的问题。我编写了2个函数，一个用于将std :: string的向量写入打开的H5File中给定名称的数据集，另一个用于将结果数据集读回到std :: string的向量中。请注意，类型之间可能需要多次复制，可以进行更优化。这是写作和阅读的工作代码：
void write_varnames( const std::string& dsetname, const std::vector<std::string>& strings, H5::H5File& f)
{
H5::Exception::dontPrint();
try
{
// HDF5 only understands vector of char* :-(
std::vector<const char*> arr_c_str;
for (size_t ii = 0; ii < strings.size(); ++ii)
{
arr_c_str.push_back(strings[ii].c_str());
}
//
// one dimension
//
hsize_t str_dimsf[1] {arr_c_str.size()};
H5::DataSpace dataspace(1, str_dimsf);
// Variable length string
H5::StrType datatype(H5::PredType::C_S1, H5T_VARIABLE);
H5::DataSet str_dataset = f.createDataSet(dsetname, datatype, dataspace);
str_dataset.write(arr_c_str.data(), datatype);
}
catch (H5::Exception& err)
{
throw std::runtime_error(std::string("HDF5 Error in ")
+ err.getFuncName()
+ ": "
+ err.getDetailMsg());
}
}
并阅读：
std::vector<std::string> read_string_dset( const std::string& dsname, H5::H5File& f )
{
H5::DataSet cdataset = f.openDataSet( dsname );
H5::DataSpace space = cdataset.getSpace();
int rank = space.getSimpleExtentNdims();
hsize_t dims_out[1];
int ndims = space.getSimpleExtentDims( dims_out, NULL);
size_t length = dims_out[0];
std::vector<const char*> tmpvect( length, NULL );
fprintf(stdout, "In read STRING dataset, got number of strings: [%ld]\n", length );
std::vector<std::string> strs(length);
H5::StrType datatype(H5::PredType::C_S1, H5T_VARIABLE);
cdataset.read( tmpvect.data(), datatype);
for(size_t x=0; x<tmpvect.size(); ++x)
{
fprintf(stdout, "GOT STRING [%s]\n", tmpvect[x] );
strs[x] = tmpvect[x];
}
return strs;
}
答案 7 :(得分：-1)
我不知道HDF5，但你可以使用
struct TempContainer {
char* string;
};
然后以这种方式复制字符串：
TempContainer t;
t.string = strdup(i->c_str());
tc.push_back (t);
这将分配一个具有确切大小的字符串，并且在插入或读取容器时也会有很大的改进（在您的示例中，复制了一个数组，在本例中只是一个指针）。您也可以使用std :: vector：
std::vector<char *> tc;
...
tc.push_back(strdup(i->c_str());