问题
我有一段旧的pre-stl C ++代码，我希望将其转换为std C ++ 11而不会降低效率。
using T = unsigned; // but can be any POD
FILE* fp = fopen( outfile.c_str(), "r" );
T* x = new T[big_n];
fread( x, sizeof(T), big_n, fp );
delete[] x;
fclose( fp );
请注意，big_n非常大 - 就像数百万条记录一样大，所以效率低下都很明显。
以前的解决方案
在上一个问题的answer中，我接受了这个解决方案：
std::vector<T> x(big_n);
fread(x.data(), sizeof(T), big_n, fp);
问题和解决方案
之前的解决方案有效，但构造函数实际上调用了T的默认构造函数big_n次。当big_n真的很大时（这完全不必要，因为我要从磁盘中fread（）整个块），这非常慢。 FWIW，在我的一个文件的测试用例中，花了3秒而不是200毫秒。
所以我尝试使用它：
std::vector<T> x;
x.reserve( big_n );
fread(x.data(), sizeof(T), big_n, fp);
这似乎有效，但后来我遇到了size（）返回0而不是big_n的问题。
如何在不降低效率的情况下纠正此问题？
附录
我刚注意到std::vector<>可以使用自定义分配器。可以使用那种形式的构造函数来解决我的问题吗？我现在正在研究这种方法。
我的工作原理
除了jrok的简单数组解决方案之外，我还研究了下面的Ali的自定义分配器解决方案。我决定采用jrock的解决方案，因为它易于理解/降低维护。
我提出的工作代码如下：
#include <vector>
#include <set>
#include <memory>
#include <fstream>
#include <iostream>
#include <cassert>
struct Foo
{
int m_i;
Foo() { }
Foo( int i ) : m_i( i ) { }
bool operator==( Foo const& rhs ) const { return m_i==rhs.m_i; }
bool operator!=( Foo const& rhs ) const { return m_i!=rhs.m_i; }
friend std::ostream& operator<<( std::ostream& os, Foo const& rhs )
{ os << rhs.m_i; }
};
// DESIGN NOTES /*{{{*/
//
// LIMITATION T must be a POD so we can fread/fwrite quickly
//
// WHY DO WE NEED THIS CLASS?
//
// We want to write a large number of small PODs to disk and read them back without
// 1. spurious calls to default constructors by std::vector
// 2. writing to disk a gazillion times
//
// SOLUTION
// A hybrid class containing a std::vector<> for adding new items and a
// std::unique_ptr<T[]> for fast persistence. From the user's POV, it looks
// like a std::vector<>.
//
// Algorithm
// 1. add new items into:
// std::vector<T> m_v;
// 2. when writing to disk, write out m_v as a chunk
// 3. when reading from disk, read into m_chunk (m_v will start empty again)
// 4. m_chunk and m_v combined will represent all the data
/*}}}*/
template<typename T>
class vector_chunk
{
// STATE /*{{{*/
size_t m_n_in_chunk;
std::unique_ptr<T[]> m_chunk;
std::vector<T> m_v;
/*}}}*/
// CONSTRUCTOR, INITIALIZATION /*{{{*/
public:
vector_chunk() : m_n_in_chunk( 0 ) { }
/*}}}*/
// EQUALITY /*{{{*/
public:
bool operator==( vector_chunk const& rhs ) const
{
if ( rhs.size()!=size() )
return false;
for( size_t i=0; i<size(); ++i )
if ( operator[]( i )!=rhs[i] )
return false;
return true;
}
/*}}}*/
// OSTREAM /*{{{*/
public:
friend std::ostream& operator<<( std::ostream& os, vector_chunk const& rhs )
{
for( size_t i=0; i<rhs.m_n_in_chunk; ++i )
os << rhs.m_chunk[i] << "\n";
for( T const& t : rhs.m_v )
os << rhs.t << "\n";
}
/*}}}*/
// BINARY I/O /*{{{*/
public:
void write_as_binary( std::ostream& os ) const
{
// write everything out
size_t const n_total = size();
os.write( reinterpret_cast<const char*>( &n_total ), sizeof( n_total ));
os.write( reinterpret_cast<const char*>( &m_chunk[0] ), m_n_in_chunk * sizeof( T ));
os.write( reinterpret_cast<const char*>( m_v.data() ), m_v.size() * sizeof( T ));
}
void read_as_binary( std::istream& is )
{
// only read into m_chunk, clear m_v
is.read( reinterpret_cast<char*>( &m_n_in_chunk ), sizeof( m_n_in_chunk ));
m_chunk.reset( new T[ m_n_in_chunk ] );
is.read( reinterpret_cast<char*>( &m_chunk[0] ), m_n_in_chunk * sizeof( T ));
m_v.clear();
}
/*}}}*/
// DELEGATION to std::vector<T> /*{{{*/
public:
size_t size() const { return m_n_in_chunk + m_v.size(); }
void push_back( T const& value ) { m_v.push_back( value ); }
void push_back( T&& value ) { m_v.push_back( value ); }
template< class... Args >
void emplace_back( Args&&... args ) { m_v.emplace_back( args... ); }
typename std::vector<T>::const_reference
operator[]( size_t pos ) const
{ return ((pos < m_n_in_chunk) ? m_chunk[ pos ] : m_v[ pos - m_n_in_chunk]); }
typename std::vector<T>::reference
operator[]( size_t pos )
{ return ((pos < m_n_in_chunk) ? m_chunk[ pos ] : m_v[ pos - m_n_in_chunk]); }
/*}}}*/
};
int main()
{
size_t const n = 10;
vector_chunk<Foo> v, w;
for( int i=0; i<n; ++i )
v.emplace_back( Foo{ i } );
std::filebuf ofb, ifb;
std::unique_ptr<std::ostream> osp;
std::unique_ptr<std::istream> isp;
ofb.open( "/tmp/junk.bin", (std::ios::out | std::ios::binary));
osp.reset( new std::ostream( &ofb ));
v.write_as_binary( *osp );
ofb.close();
ifb.open( "/tmp/junk.bin", (std::ios::in | std::ios::binary));
isp.reset( new std::istream( &ifb ));
w.read_as_binary( *isp );
ifb.close();
assert( v==w );
}
答案 0 :(得分：5)
使用vector::reserve()然后写入vector::data()是一种肮脏的黑客行为和未定义的行为。请不要这样做。
解决此问题的方法是使用自定义分配器，例如in this answer。我刚测试过它，与clang 3.5 trunk一起工作正常但不能用gcc 4.7.2编译。
虽然正如其他人已经指出的那样，unique_ptr<T[]>会很好地满足您的需求。
答案 1 :(得分：4)
如果您不需要矢量的界面：
auto p = unique_ptr<T[]>{ new T[big_n] };
如果T是POD，它将不会初始化数组，否则它会调用默认构造函数（默认初始化）。
在C ++ 1y中，您将能够使用std::make_unique。
答案 2 :(得分：2)
如果使用boost是一个选项，那么从版本1.55开始使用以下语法来增强:: container :: vector has had support for explicitly default-initializing elements when resizing：
using namespace boost::container;
vector<T> vector(37283, default_init);
创建时或
using namespace boost::container;
vector.resize(37283, default_init);
创作后。这导致了很好的语法：
using T = unsigned; // but can be any trivially copyable type
FILE* fp = fopen( outfile.c_str(), "r" );
boost::container::vector<T> x(big_n, boost::container::default_init);
fread( x.data(), sizeof(T), big_n, fp );
fclose( fp );
在我的测试中，性能与使用std::vector和默认初始化分配器相同。
编辑：不相关，我会为FILE*使用RAII包装器：
struct FILE_deleter {
void operator () (FILE* f) const {
if (f) fclose(f);
}
};
using FILE_ptr = std::unique_ptr<FILE, FILE_deleter>;
using T = unsigned; // but can be any trivially copyable type
FILE_ptr fp{fopen( outfile.c_str(), "r" )};
boost::container::vector<T> x(big_n, boost::container::default_init);
fread( x.data(), sizeof(T), big_n, fp.get() );
我对RAII有点强迫症。
编辑2：另一种选择，如果你绝对必须产生std::vector<T>，而不是boost::container::vector<T>或std::vector<T, default_allocator<T>>，则是从自定义迭代器对填充std::vector<T> 。这是制作fread迭代器的一种方法：
template <typename T>
class fread_iterator :
public boost::iterator_facade<fread_iterator<T>, T,
std::input_iterator_tag, T> {
friend boost::iterator_core_access;
bool equal(const fread_iterator& other) const {
return (file_ && feof(file_)) || n_ <= other.n_;
}
T dereference() const {
// is_trivially_copyable is sufficient, but libstdc++
// (for whatever reason) doesn't have that trait.
static_assert(std::is_pod<T>::value,
"Jabberwocky is killing user.");
T result;
fread(&result, sizeof(result), 1, file_);
return result;
}
void increment() { --n_; }
FILE* file_;
std::size_t n_;
public:
fread_iterator() : file_(nullptr), n_(0) {}
fread_iterator(FILE* file, std::size_t n) : file_(file), n_(n) {}
};
（我使用boost::iterator_facade来减少迭代器样板。）这里的想法是编译器可以忽略dereference的返回值的移动构造，以便fread将直接读入vector的内存缓冲区。由于每个项目调用fread一次而对于分配器修改方法只调用一次，因此可能效率较低，但没有太糟糕，因为（a）文件数据仍然只从stdio缓冲区复制一次到向量中，（b）缓冲IO的重点是粒度影响较小。您可以使用其assign(iterator, iterator)成员填充向量：
using T = unsigned; // but can be any trivially copyable type
FILE_ptr fp{fopen( outfile.c_str(), "r" )};
std::vector<T> x;
x.reserve(big_n);
x.assign(fread_iterator<T>{fp.get(), big_n}, fread_iterator<T>{});
Throwing it all together and testing side-by-side，此迭代器方法比使用自定义分配器方法或boost::container::vector慢约10％。分配器和增强方法具有几乎相同的性能。
答案 3 :(得分：1)
由于您要升级到c ++ 11，为什么不使用文件流呢？我只是尝试使用ifstream＆amp;读取17 MB到char *然后使用ofstream将内容写入文件。
我在循环中运行相同的应用程序15次，最长时间为320毫秒，最小值为120毫秒。
std::unique_ptr<char []> ReadToEnd(const char* filename)
{
std::ifstream inpfile(filename, std::ios::in | std::ios::binary | std::ios::ate);
std::unique_ptr<char[]> ret;
if (inpfile.is_open())
{
auto sz = static_cast<size_t>(inpfile.tellg());
inpfile.seekg(std::ios::beg);
ret.reset(new char[sz + 1]);
ret[sz] = '\0';
inpfile.read(ret.get(), sz);
}
return ret;
}
int main(int argc, char* argv [])
{
auto data = ReadToEnd(argv[1]);
std::cout << "Num of characters in file:" << strlen(data.get()) << "\n";
std::ofstream outfile("output.txt");
outfile.write(data.get(), strlen(data.get()));
}
<强>输出
D：\ code \ cpp \ ConsoleApplication1 \ Release＆gt; ConsoleApplication1.exe d：\ code \ cpp \ SampleApp \ Release \ output.txt
文件中的字符数：18805057
读取文件所花费的时间，d：\ code \ cpp \ SampleApp \ Release \ output.txt：152.008 ms。