我有一个 char* 和从库接收的数据长度,我需要将数据传递给一个接受 istream 的函数。
我知道我可以创建一个字符串流,但这会复制所有数据。而且,数据肯定会有 0,因为它是一个 zip 文件,并且创建一个字符串流会将数据带到我认为的第一个 0。
有什么方法可以从 char* 创建 istream 并且它的大小而不复制所有数据?
这是在 web 上找到的不推荐使用的方法,您是否派生了自己的std::streambuf
类,但简单且似乎有效:
#include <iostream>
#include <istream>
#include <streambuf>
#include <string>
struct membuf : std::streambuf
{
membuf(char* begin, char* end) {
this->setg(begin, begin, end);
}
};
int main()
{
char buffer[] = "I'm a buffer with embedded nulls\0and line\n feeds";
membuf sbuf(buffer, buffer + sizeof(buffer));
std::istream in(&sbuf);
std::string line;
while (std::getline(in, line)) {
std::cout << "line: " << line << "\n";
}
return 0;
}
哪个输出:
line: I'm a buffer with embedded nullsand line
line: feeds
使用 Boost 的非弃用解决方案:
#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/array.hpp>
using namespace boost::iostreams;
basic_array_source<char> input_source(my_ptr_to_char, byte_count);
stream<basic_array_source<char> > input_stream(input_source);
甚至更简单:
#include <boost/interprocess/streams/bufferstream.hpp>
using namespace boost::interprocess;
bufferstream input_stream(my_ptr_to_char, byte_count);
唯一(简单)的可移植方式包括制作副本:
std::istringstream ss(std::string(buf,len));
实际上,这很可能会复制数据两次,一次string
创建istringstream
. (也许 C++11 可以通过移动构造函数避免其中一个副本;我不确定。)
但是,如果幸运的话,您的 C++ 实现将允许您这样做:
std::istringstream ss;
ss.rdbuf()->pubsetbuf(buf,len);
在 GNU C++(我相信还有其他一些实现)下,这将在不复制数据的情况下创建字符串流。但根据规范,这是“实现定义的”行为。(另见这个问题。)
通过包含len
参数,您可以确保这两个都不会出现空字符问题。
做你想做的唯一可移植的方法是实现你自己的子类stringbuf
并使用它来初始化字符串流。不适合胆小的人。
我需要一个支持tellg
并且seekg
不需要提升的解决方案。
char_array_buffer
从初学者指南到编写自定义流缓冲区 (std::streambuf)给出了一个起点。
byte_array_buffer.h:
#include <cstdio>
#include <string>
#include <list>
#include <fstream>
#include <iostream>
//
// http://www.mr-edd.co.uk/blog/beginners_guide_streambuf
//
class byte_array_buffer : public std::streambuf
{
public:
byte_array_buffer(const uint8_t *begin, const size_t size);
private:
int_type underflow();
int_type uflow();
int_type pbackfail(int_type ch);
std::streamsize showmanyc();
std::streampos seekoff ( std::streamoff off, std::ios_base::seekdir way,
std::ios_base::openmode which = std::ios_base::in | std::ios_base::out );
std::streampos seekpos ( std::streampos sp,
std::ios_base::openmode which = std::ios_base::in | std::ios_base::out);
// copy ctor and assignment not implemented;
// copying not allowed
byte_array_buffer(const byte_array_buffer &);
byte_array_buffer &operator= (const byte_array_buffer &);
private:
const uint8_t * const begin_;
const uint8_t * const end_;
const uint8_t * current_;
};
byte_array_buffer.cpp:
#include "byte_array_buffer.h"
#include <cassert>
byte_array_buffer::byte_array_buffer(const uint8_t *begin, const size_t size) :
begin_(begin),
end_(begin + size),
current_(begin_)
{
assert(std::less_equal<const uint8_t *>()(begin_, end_));
}
byte_array_buffer::int_type byte_array_buffer::underflow()
{
if (current_ == end_)
return traits_type::eof();
return traits_type::to_int_type(*current_);
}
byte_array_buffer::int_type byte_array_buffer::uflow()
{
if (current_ == end_)
return traits_type::eof();
return traits_type::to_int_type(*current_++);
}
byte_array_buffer::int_type byte_array_buffer::pbackfail(int_type ch)
{
if (current_ == begin_ || (ch != traits_type::eof() && ch != current_[-1]))
return traits_type::eof();
return traits_type::to_int_type(*--current_);
}
std::streamsize byte_array_buffer::showmanyc()
{
assert(std::less_equal<const uint8_t *>()(current_, end_));
return end_ - current_;
}
std::streampos byte_array_buffer::seekoff ( std::streamoff off, std::ios_base::seekdir way,
std::ios_base::openmode which )
{
if (way == std::ios_base::beg)
{
current_ = begin_ + off;
}
else if (way == std::ios_base::cur)
{
current_ += off;
}
else if (way == std::ios_base::end)
{
current_ = end_ + off;
}
if (current_ < begin_ || current_ > end_)
return -1;
return current_ - begin_;
}
std::streampos byte_array_buffer::seekpos ( std::streampos sp,
std::ios_base::openmode which )
{
current_ = begin_ + sp;
if (current_ < begin_ || current_ > end_)
return -1;
return current_ - begin_;
}
支持tellg和seekg的已接受答案的扩展:
struct membuf : std::streambuf
{
membuf(char* begin, char* end)
{
this->setg(begin, begin, end);
}
pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode which = std::ios_base::in) override
{
if (dir == std::ios_base::cur)
gbump(off);
else if (dir == std::ios_base::end)
setg(eback(), egptr() + off, egptr());
else if (dir == std::ios_base::beg)
setg(eback(), eback() + off, egptr());
return gptr() - eback();
}
pos_type seekpos(pos_type sp, std::ios_base::openmode which) override
{
return seekoff(sp - pos_type(off_type(0)), std::ios_base::beg, which);
}
};
这个类的用法保持不变。
你试过 std::istrstream 吗? http://stdcxx.apache.org/doc/stdlibref/istrstream.html
从技术上讲,我认为它已被弃用,但仍然是标准的一部分。
试试 Boost.Iostreams 数组源和接收器类。
http://www.boost.org/doc/libs/1_47_0/libs/iostreams/doc/index.html