Cách đơn giản để tạo bộ nhớ C++ từ (char *, size_t), mà không sao chép dữ liệu?

Question

tôi không thể tìm thấy bất cứ điều gì làm sẵn, vì vậy tôi đã đưa ra:

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

Cách sử dụng:

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

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

tôi biết stringstream, nhưng nó dường như không có khả năng làm việc với dữ liệu nhị phân có độ dài đã cho.

Tôi có phát minh ra bánh xe của riêng mình ở đây không?

EDIT

• Nó phải không sao chép các dữ liệu đầu vào, chỉ cần tạo cái gì đó sẽ lặp qua các dữ liệu.
• Nó phải di động - ít nhất nó phải hoạt động cả dưới gcc và MSVC.

Answer 1

Tôi giả định rằng dữ liệu đầu vào của bạn là nhị phân (không phải văn bản) và bạn muốn trích xuất khối dữ liệu nhị phân từ nó. Tất cả mà không cần tạo bản sao dữ liệu đầu vào của bạn.

Bạn có thể kết hợp boost::iostreams::basic_array_source và boost::iostreams::stream_buffer (từ Boost.Iostreams) với boost::archive::binary_iarchive (từ Boost.Serialization) để có thể sử dụng khai thác >> khai thác thuận tiện để đọc khối dữ liệu nhị phân.

#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; 
} 

Với GCC 4.4.1 trên AMD64, nó kết quả đầu ra:

1234,5678

Boost.Serialization là rất mạnh mẽ và biết làm thế nào để serialize tất cả các loại cơ bản, chuỗi, và thậm chí cả các container STL. Bạn có thể dễ dàng làm cho các loại của bạn serializable. Xem tài liệu. Ẩn ở đâu đó trong các nguồn Boost.Serialization là một ví dụ về một kho lưu trữ nhị phân di động biết cách thực hiện trao đổi thích hợp cho tính cuối cùng của máy. Điều này có thể hữu ích cho bạn.

Nếu bạn không cần fanciness của Boost.Serialization và rất vui khi được đọc dữ liệu nhị phân trong một fread() - loại thời trang, bạn có thể sử dụng basic_array_source theo một cách đơn giản hơn:

#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; 
} 

tôi nhận được cùng một đầu ra với chương trình này.

Answer 2

Tôi không chắc chắn những gì bạn cần, nhưng điều này có làm những gì bạn muốn không?

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

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

Answer 3

Bộ đệm dòng tiêu chuẩn có chức năng này.
Tạo luồng. Được bộ đệm của nó sau đó hơn-đi xe nó.

#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

Người hỏi muốn nội dung nào đó không sao chép dữ liệu và giải pháp của anh ấy hoạt động tốt. Đóng góp của tôi là làm sạch nó một chút, vì vậy bạn chỉ có thể tạo một đối tượng duy nhất là luồng đầu vào cho dữ liệu trong bộ nhớ. Tôi đã thử nghiệm này và nó hoạt động.

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; 
    };