從（char *，size_t）創建C++內存流的簡單方法，無需複製數據？

Question

我找不到任何現成的，所以我想出了：

class membuf : public basic_streambuf<char> 
{ 
public: 
    membuf(char* p, size_t n) { 
    setg(p, p, p + n); 
    setp(p, p + n); 
    } 
} 

用法：

char *mybuffer; 
size_t length; 
// ... allocate "mybuffer", put data into it, set "length" 

membuf mb(mybuffer, length); 
istream reader(&mb); 
// use "reader" 

我知道stringstream，但它似乎並沒有能夠工作與給定長度的二進制數據。

我在這裏發明了自己的車輪嗎？

編輯

• 它不得複製輸入數據，剛剛創造的東西，會遍歷數據。
• 它必須是可移植的 - 至少它應該同時在gcc和MSVC下工作。

Answer 1

我假設你的輸入數據是二進制（不是文本），並且你想從中提取二進制數據塊。所有這些都不需要複製輸入數據。

您可以結合boost::iostreams::basic_array_source和boost::iostreams::stream_buffer（從Boost.Iostreams）與boost::archive::binary_iarchive（從Boost.Serialization），以能夠使用便捷的提取>>運營商讀取二進制數據塊。

#include <stdint.h> 
#include <iostream> 
#include <boost/iostreams/device/array.hpp> 
#include <boost/iostreams/stream.hpp> 
#include <boost/archive/binary_iarchive.hpp> 

int main() 
{ 
    uint16_t data[] = {1234, 5678}; 
    char* dataPtr = (char*)&data; 

    typedef boost::iostreams::basic_array_source<char> Device; 
    boost::iostreams::stream_buffer<Device> buffer(dataPtr, sizeof(data)); 
    boost::archive::binary_iarchive archive(buffer, boost::archive::no_header); 

    uint16_t word1, word2; 
    archive >> word1 >> word2; 
    std::cout << word1 << "," << word2 << std::endl; 
    return 0; 
} 

隨着AMD64 GCC 4.4.1，它輸出：

1234,5678

Boost.Serialization是非常強大的，並且知道如何連載所有的基本類型，字符串，甚至STL容器。你可以很容易地讓你的類型可序列化。請參閱文檔。隱藏在Boost.Serialization源代碼中的某個地方是一個便攜式二進制歸檔文件的例子，它知道如何爲您的機器的字節順序執行適當的交換。這對你也可能有用。

如果您不需要Boost.Serialization的裝飾性，並很高興在FREAD讀取二進制數據（） - 時尚型，你可以在一個更簡單的方式使用basic_array_source：

#include <stdint.h> 
#include <iostream> 
#include <boost/iostreams/device/array.hpp> 
#include <boost/iostreams/stream.hpp> 

int main() 
{ 
    uint16_t data[] = {1234, 5678}; 
    char* dataPtr = (char*)&data; 

    typedef boost::iostreams::basic_array_source<char> Device; 
    boost::iostreams::stream<Device> stream(dataPtr, sizeof(data)); 

    uint16_t word1, word2; 
    stream.read((char*)&word1, sizeof(word1)); 
    stream.read((char*)&word2, sizeof(word2)); 
    std::cout << word1 << "," << word2 << std::endl; 

    return 0; 
} 

我用這個程序得到相同的輸出。

Answer 2

我不確定你需要什麼，但是這樣做你想做什麼？

char *mybuffer; 
size_t length; 
// allocate, fill, set length, as before 

std::string data(mybuffer, length); 
std::istringstream mb(data); 
//use mb 

Answer 3

標準流緩衝區具有此功能。
創建一個流。獲取緩衝區然後覆蓋它。

#include <sstream> 
#include <iostream> 
#include <algorithm> 
#include <iterator> 

int main() 
{ 
    // Your imaginary buffer 
    char buffer[] = "A large buffer we don't want to copy but use in a stream"; 

    // An ordinary stream. 
    std::stringstream str; 

    // Get the streams buffer object. Reset the actual buffer being used. 
    str.rdbuf()->pubsetbuf(buffer,sizeof(buffer)); 

    std::copy(std::istreambuf_iterator<char>(str), 
       std::istreambuf_iterator<char>(), 
       std::ostream_iterator<char>(std::cout) 
      ); 
} 

Answer 4

提問者想要一些不復制數據，他的解決方案正常工作。我的貢獻是稍微清理一下，所以你可以創建一個單一的對象，這個對象是內存中數據的輸入流。我已經測試過它，它的工作原理。

class MemoryInputStream: public std::istream 
    { 
    public: 
    MemoryInputStream(const uint8_t* aData,size_t aLength): 
     std::istream(&m_buffer), 
     m_buffer(aData,aLength) 
     { 
     rdbuf(&m_buffer); // reset the buffer after it has been properly constructed 
     } 

    private: 
    class MemoryBuffer: public std::basic_streambuf<char> 
     { 
     public: 
     MemoryBuffer(const uint8_t* aData,size_t aLength) 
      { 
      setg((char*)aData,(char*)aData,(char*)aData + aLength); 
      } 
     }; 

    MemoryBuffer m_buffer; 
    };