ByteStream

最新推荐文章于 2024-06-25 20:45:00 发布
最新推荐文章于 2024-06-25 20:45:00 发布
阅读量1.7k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 工具 c++ 文章标签： byte float buffer string ui stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxxmaker/article/details/7543839

前公司有个这样的类(感觉很像stringstream)，主要是网络中传数据用的(大概是因为要考虑字节序的问题，所以有了这么一个类)，不过公司的实现有一个可移植性的问题：比如将网络中的一端流入一个int/long类型的数据，只要两端int/long占用字节大小不一致，那么在网络的另一端流出就会出问题。

今天自己依据其原理写了个，当然我的实现在空间上是不及前公司的，因为前公司的有一些优化，比如bool只占1bit，一个int数据可能占1/2/3/4byte；我的没有这些，bool占1bit的思想，我感觉写在上层更好，如果有必要的话；对于比较小的数压缩下空间倒是不错的想法。另外，公司是一个类，我的是三个。

写这篇文章不会被告侵权吧？！

#ifndef __BYTE_STREAM_H__
#define __BYTE_STREAM_H__

#include <string>
using std::string;

class ByteStream
{
public:
    ByteStream(unsigned short len);
    ~ByteStream();

private:
    ByteStream(const ByteStream &);
    ByteStream & operator = (const ByteStream &);

public:
    static void big2little(void * obj, unsigned int size);

    bool seek(unsigned short offset);
    unsigned short tell();
    unsigned short left();

protected:
    unsigned short m_length;
    unsigned short m_offset;
};

class OBStream : public ByteStream
{
public:
    OBStream(char * byte, unsigned short len);
    ~OBStream();

public:
    void init(char * byte, unsigned short len);

    bool writebytes(unsigned short offset, 
                    const void * obj, unsigned short size);

public:
    OBStream & write(const char * ptr, unsigned short size);

    OBStream & operator << (bool);
    OBStream & operator << (signed char);
    OBStream & operator << (unsigned char);
    OBStream & operator << (signed short);
    OBStream & operator << (unsigned short);
    OBStream & operator << (signed int);
    OBStream & operator << (unsigned int);
    OBStream & operator << (signed long);
    OBStream & operator << (unsigned long);
    OBStream & operator << (float);
    OBStream & operator << (double);

    OBStream & operator << (const string &);

private:
    char * m_byte;
};

class IBStream : public ByteStream
{
public:
    IBStream(const char * byte, unsigned short len);
    ~IBStream();

public:
    void init(const char * byte, unsigned short len);

    bool readbytes(unsigned short offset, 
                   void * obj, unsigned short size);

public:
    IBStream & read(char * ptr, unsigned short size);

    IBStream & operator >> (bool &);
    IBStream & operator >> (signed char &);
    IBStream & operator >> (unsigned char &);
    IBStream & operator >> (signed short &);
    IBStream & operator >> (unsigned short &);
    IBStream & operator >> (signed int &);
    IBStream & operator >> (unsigned int &);
    IBStream & operator >> (signed long &);
    IBStream & operator >> (unsigned long &);
    IBStream & operator >> (float &);
    IBStream & operator >> (double &);

    IBStream & operator >> (string &);

private:
    const char * m_byte;
};

#endif

#include <cassert>
#include <cstring>
#include "ByteStream.h"


ByteStream::ByteStream(unsigned short len)
 : m_length(len), m_offset(0)
{
    
}

ByteStream::~ByteStream()
{
    
}

void ByteStream::big2little(void * obj, unsigned int size)
{
    static union {
        unsigned short us;
        unsigned char  uc[sizeof(unsigned short)];
    } un;
    un.us = 0x0001;

    if (0x00 == un.uc[0]) {
        char * ptr = static_cast<char *>(obj);
        for (int i = 0; i < size / 2; ++i) {
            char temp = ptr[i];
            ptr[i] = ptr[size - 1 - i];
            ptr[size - 1 - i] = temp;
        }
    }
}

bool ByteStream::seek(unsigned short offset)
{
    if (offset <= m_length) {
        m_offset = offset;
        return(true);
    }
    else {
        return(false);
    }
}

unsigned short ByteStream::tell()
{
    return(m_offset);
}

unsigned short ByteStream::left()
{
    return(m_length - m_offset);
}

OBStream::OBStream(char * byte, unsigned short len)
 : ByteStream(len), m_byte(byte)
{
    
}

OBStream::~OBStream()
{
    
}

void OBStream::init(char * byte, unsigned short len)
{
    m_length = len;
    m_offset = 0;
    m_byte = byte;
}

bool OBStream::writebytes(unsigned short offset, 
                          const void * obj, unsigned short size)
{
    if (offset + size <= m_length) {
        memcpy(m_byte + offset, obj, size);
        return(true);
    }
    else {
        return(false);
    }
}

OBStream & OBStream::write(const char * ptr, unsigned short size)
{
    assert(m_offset + size <= m_length);
    writebytes(m_offset, ptr, size);
    m_offset += size;
    return(*this);
}

OBStream & OBStream::operator << (bool value)
{
    assert(m_offset + sizeof(bool) <= m_length);
    big2little(&value, sizeof(bool));
    writebytes(m_offset, &value, sizeof(bool));
    m_offset += sizeof(bool);
    return(*this);
}

OBStream & OBStream::operator << (signed char value)
{
    assert(m_offset + sizeof(signed char) <= m_length);
    big2little(&value, sizeof(signed char));
    writebytes(m_offset, &value, sizeof(signed char));
    m_offset += sizeof(signed char);
    return(*this);
}

OBStream & OBStream::operator << (unsigned char value)
{
    assert(m_offset + sizeof(unsigned char) <= m_length);
    big2little(&value, sizeof(unsigned char));
    writebytes(m_offset, &value, sizeof(unsigned char));
    m_offset += sizeof(unsigned char);
    return(*this);
}

OBStream & OBStream::operator << (signed short value)
{
    assert(m_offset + sizeof(signed short) <= m_length);
    big2little(&value, sizeof(signed short));
    writebytes(m_offset, &value, sizeof(signed short));
    m_offset += sizeof(signed short);
    return(*this);
}
OBStream & OBStream::operator << (unsigned short value)
{
    assert(m_offset + sizeof(unsigned short) <= m_length);
    big2little(&value, sizeof(unsigned short));
    writebytes(m_offset, &value, sizeof(unsigned short));
    m_offset += sizeof(unsigned short);
    return(*this);
}

OBStream & OBStream::operator << (signed int value)
{
    assert(m_offset + sizeof(unsigned char) + sizeof(signed int) <= m_length);
    unsigned char size = static_cast<unsigned char>(sizeof(signed int));
    operator << (size);
    big2little(&value, sizeof(signed int));
    writebytes(m_offset, &value, sizeof(signed int));
    m_offset += sizeof(signed int);
    return(*this);
}

OBStream & OBStream::operator << (unsigned int value)
{
    assert(m_offset + sizeof(unsigned char) + sizeof(unsigned int) <= m_length);
    unsigned char size = static_cast<unsigned char>(sizeof(unsigned int));
    operator << (size);
    big2little(&value, sizeof(unsigned int));
    writebytes(m_offset, &value, sizeof(unsigned int));
    m_offset += sizeof(unsigned int);
    return(*this);
}

OBStream & OBStream::operator << (signed long value)
{
    assert(m_offset + sizeof(unsigned char) + sizeof(signed long) <= m_length);
    unsigned char size = static_cast<unsigned char>(sizeof(signed long));
    operator << (size);
    big2little(&value, sizeof(signed long));
    writebytes(m_offset, &value, sizeof(signed long));
    m_offset += sizeof(signed long);
    return(*this);
}

OBStream & OBStream::operator << (unsigned long value)
{
    assert(m_offset + sizeof(unsigned char) + sizeof(unsigned long) <= m_length);
    unsigned char size = static_cast<unsigned char>(sizeof(unsigned long));
    operator << (size);
    big2little(&value, sizeof(unsigned long));
    writebytes(m_offset, &value, sizeof(unsigned long));
    m_offset += sizeof(unsigned long);
    return(*this);
}

OBStream & OBStream::operator << (float value)
{
    assert(m_offset + sizeof(float) <= m_length);
    big2little(&value, sizeof(float));
    writebytes(m_offset, &value, sizeof(float));
    m_offset += sizeof(float);
    return(*this);
}

OBStream & OBStream::operator << (double value)
{
    assert(m_offset + sizeof(double) <= m_length);
    big2little(&value, sizeof(double));
    writebytes(m_offset, &value, sizeof(double));
    m_offset += sizeof(double);
    return(*this);
}

OBStream & OBStream::operator << (const string & value)
{
    assert(m_offset + sizeof(unsigned short) + value.size() <= m_length);
    unsigned short size = static_cast<unsigned short>(value.size());
    operator << (size);
    write(value.c_str(), size);
    return(*this);
}


IBStream::IBStream(const char * byte, unsigned short len)
 : ByteStream(len), m_byte(byte)
{
    
}

IBStream::~IBStream()
{
    
}

void IBStream::init(const char * byte, unsigned short len)
{
    m_length = len;
    m_offset = 0;
    m_byte = byte;
}

bool IBStream::readbytes(unsigned short offset, 
                         void * obj, unsigned short size)
{
    if (offset + size <= m_length) {
        memcpy(obj, m_byte + offset, size);
        return(true);
    }
    else {
        return(false);
    }
}

IBStream & IBStream::read(char * ptr, unsigned short size)
{
    assert(m_offset + size <= m_length);
    readbytes(m_offset, ptr, size);
    m_offset += size;
    return(*this);
}

IBStream & IBStream::operator >> (bool & value)
{
    assert(m_offset + sizeof(bool) <= m_length);
    readbytes(m_offset, &value, sizeof(bool));
    big2little(&value, sizeof(bool));
    m_offset += sizeof(bool);
    return(*this);
}

IBStream & IBStream::operator >> (signed char & value)
{
    assert(m_offset + sizeof(signed char) <= m_length);
    readbytes(m_offset, &value, sizeof(signed char));
    big2little(&value, sizeof(signed char));
    m_offset += sizeof(signed char);
    return(*this);
}

IBStream & IBStream::operator >> (unsigned char & value)
{
    assert(m_offset + sizeof(unsigned char) <= m_length);
    readbytes(m_offset, &value, sizeof(unsigned char));
    big2little(&value, sizeof(unsigned char));
    m_offset += sizeof(unsigned char);
    return(*this);
}

IBStream & IBStream::operator >> (signed short & value)
{
    assert(m_offset + sizeof(signed short) <= m_length);
    readbytes(m_offset, &value, sizeof(signed short));
    big2little(&value, sizeof(signed short));
    m_offset += sizeof(signed short);
    return(*this);
}

IBStream & IBStream::operator >> (unsigned short & value)
{
    assert(m_offset + sizeof(unsigned short) <= m_length);
    readbytes(m_offset, &value, sizeof(unsigned short));
    big2little(&value, sizeof(unsigned short));
    m_offset += sizeof(unsigned short);
    return(*this);
}

IBStream & IBStream::operator >> (signed int & value)
{
    assert(m_offset + sizeof(unsigned char) <= m_length);
    unsigned char size = 0;
    operator >> (size);
    assert(m_offset + size <= m_length);
    if (sizeof(signed int) == size) {
        readbytes(m_offset, &value, sizeof(signed int));
        big2little(&value, sizeof(signed int));
        m_offset += sizeof(signed int);
    }
    else if (sizeof(signed int) > size) {
        value = 0;
        unsigned char * ptr = reinterpret_cast<unsigned char *>(&value);
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(&value, sizeof(signed int));
    }
    else {
        assert(sizeof(signed int) <= 8);
        unsigned char ptr[8] = { 0 };
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(ptr, size);
        value = *(reinterpret_cast<signed int *>(ptr));
    }
    return(*this);
}

IBStream & IBStream::operator >> (unsigned int & value)
{
    assert(m_offset + sizeof(unsigned char) <= m_length);
    unsigned char size = 0;
    operator >> (size);
    assert(m_offset + size <= m_length);
    if (sizeof(unsigned int) == size) {
        readbytes(m_offset, &value, sizeof(unsigned int));
        big2little(&value, sizeof(unsigned int));
        m_offset += sizeof(unsigned int);
    }
    else if (sizeof(unsigned int) > size) {
        value = 0;
        unsigned char * ptr = reinterpret_cast<unsigned char *>(&value);
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(&value, sizeof(unsigned int));
    }
    else {
        assert(sizeof(unsigned int) <= 8);
        unsigned char ptr[8] = { 0 };
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(ptr, size);
        value = *(reinterpret_cast<unsigned int *>(ptr));
    }
    return(*this);
}

IBStream & IBStream::operator >> (signed long & value)
{
    assert(m_offset + sizeof(unsigned char) <= m_length);
    unsigned char size = 0;
    operator >> (size);
    assert(m_offset + size <= m_length);
    if (sizeof(signed long) == size) {
        readbytes(m_offset, &value, sizeof(signed long));
        big2little(&value, sizeof(signed long));
        m_offset += sizeof(signed long);
    }
    else if (sizeof(signed long) > size) {
        value = 0;
        unsigned char * ptr = reinterpret_cast<unsigned char *>(&value);
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(&value, sizeof(signed long));
    }
    else {
        assert(sizeof(signed long) <= 8);
        unsigned char ptr[8] = { 0 };
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(ptr, size);
        value = *(reinterpret_cast<signed long *>(ptr));
    }
    return(*this);
}

IBStream & IBStream::operator >> (unsigned long & value)
{
    assert(m_offset + sizeof(unsigned char) <= m_length);
    unsigned char size = 0;
    operator >> (size);
    assert(m_offset + size <= m_length);
    if (sizeof(unsigned long) == size) {
        readbytes(m_offset, &value, sizeof(unsigned long));
        big2little(&value, sizeof(unsigned long));
        m_offset += sizeof(unsigned long);
    }
    else if (sizeof(unsigned long) > size) {
        value = 0;
        unsigned char * ptr = reinterpret_cast<unsigned char *>(&value);
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(&value, sizeof(unsigned long));
    }
    else {
        assert(sizeof(unsigned long) <= 8);
        unsigned char ptr[8] = { 0 };
        for (int i = 0; i < size; ++i) {
            operator >> (ptr[i]);
        }
        big2little(ptr, size);
        value = *(reinterpret_cast<unsigned long *>(ptr));
    }
    return(*this);
}

IBStream & IBStream::operator >> (float & value)
{
    assert(m_offset + sizeof(float) <= m_length);
    readbytes(m_offset, &value, sizeof(float));
    big2little(&value, sizeof(float));
    m_offset += sizeof(float);
    return(*this);
}

IBStream & IBStream::operator >> (double & value)
{
    assert(m_offset + sizeof(double) <= m_length);
    readbytes(m_offset, &value, sizeof(double));
    big2little(&value, sizeof(double));
    m_offset += sizeof(double);
    return(*this);
}

IBStream & IBStream::operator >> (string & value)
{
    assert(m_offset + sizeof(unsigned short) <= m_length);
    unsigned short size = 0;
    operator >> (size);
    assert(m_offset + size <= m_length);
    value.resize(size);
    read(&value[0], size);
    return(*this);
}

#include <complex>
#include <string>
#include <iostream>
using namespace std;

#include "ByteStream.h"

template <typename T>
OBStream & operator << (OBStream & obs, const complex<T> & comp)
{
    return(obs << comp.real() << comp.imag());
}

template <typename T>
IBStream & operator >> (IBStream & ibs, complex<T> & comp)
{
    T real;
    T imag;
    ibs >> real >> imag;
    comp = complex<T>(real, imag);
    return(ibs);
}

int main(int argc, char * argv[])
{
    char buffer[100] = { 0 };

    bool           in_b = true;
    signed char    in_sc = 'a';
    unsigned char  in_uc = 'A';
    signed short   in_ss = 12345;
    unsigned short in_us = 65535;
    signed int     in_si = 123456789;
    unsigned int   in_ui = 987654321;
    signed long    in_sl = 11223344;
    unsigned long  in_ul = 66554433;
    float          in_f  = 123456.789f;
    double         in_d = 987654321.123456789;
    const char   * in_ptr = "ByteStream";
    string         in_str("Hello World");
    complex<int>   in_comp(123, 456);

    cout << in_b << endl;
    cout << in_sc << endl;
    cout << in_uc << endl;
    cout << in_ss << endl;
    cout << in_us << endl;
    cout << in_si << endl;
    cout << in_ui << endl;
    cout << in_sl << endl;
    cout << in_ul << endl;
    cout << in_f << endl;
    cout << in_d << endl;
    cout << in_ptr << endl;
    cout << in_str << endl;
    cout << in_comp << endl;

    unsigned short in_size = 0;
    OBStream obs(buffer, 100);
    (obs << in_size << in_b << in_sc << in_uc << in_ss 
         << in_us << in_si << in_ui << in_sl << in_ul 
         << in_f << in_d).write(in_ptr, 10) << in_str << in_comp;
    in_size = obs.tell();
    obs.seek(0);
    obs << in_size;
    obs.seek(in_size);

    cout << "write " << in_size << " Bytes" << endl;

    unsigned short out_size;
    bool           out_b;
    signed char    out_sc;
    unsigned char  out_uc;
    signed short   out_ss;
    unsigned short out_us;
    signed int     out_si;
    unsigned int   out_ui;
    signed long    out_sl;
    unsigned long  out_ul;
    float          out_f;
    double         out_d;
    char           out_ptr[11] = { 0 };
    string         out_str;
    complex<int>   out_comp;

    IBStream ibs(buffer, obs.tell());
    (ibs >> out_size >> out_b >> out_sc >> out_uc >> out_ss 
         >> out_us >> out_si >> out_ui >> out_sl >> out_ul 
         >> out_f >> out_d).read(out_ptr, 10) >> out_str >> out_comp;

    cout << "read " << out_size << " Bytes" << endl;
    cout << out_b << endl;
    cout << out_sc << endl;
    cout << out_uc << endl;
    cout << out_ss << endl;
    cout << out_us << endl;
    cout << out_si << endl;
    cout << out_ui << endl;
    cout << out_sl << endl;
    cout << out_ul << endl;
    cout << out_f << endl;
    cout << out_d << endl;
    cout << out_ptr << endl;
    cout << out_str << endl;
    cout << out_comp << endl;

    return(0);
}


#include <iostream>
using namespace std;

#include "ByteStream.h"

int main(int argc, char * argv[])
{
    char buffer[32] = { 0 };
    unsigned short in_int = 65535;
    unsigned char  in_int_len = sizeof(unsigned short);
    long in_long = 123456;
    double * in_p_long = reinterpret_cast<double *>(&in_long);
    unsigned char in_long_len = sizeof(double);

    unsigned short in_size = 0;
    OBStream obs(buffer, 100);
    obs << in_size;
    obs << in_int_len << in_int;        /* less-int: (len + short) like a 16bit-int*/
    obs << in_long_len << (*in_p_long); /* large-long: (len + double) like a 64bit-long */
    in_size = obs.tell();
    obs.seek(0);
    obs << in_size;
    obs.seek(in_size);

    cout << in_int << endl;
    cout << in_long << endl;
    cout << "write " << in_size << " Bytes" << endl;

    unsigned short out_size = 0;
    signed int     out_int = 0;
    signed long    out_long = 0;

    IBStream ibs(buffer, obs.tell());
    ibs >> out_size;
    ibs >> out_int;  /* large-int */
    ibs >> out_long; /* less-long */

    cout << "read " << out_size << " Bytes" << endl;
    cout << out_int << endl;
    cout << out_long << endl;

    return(0);
}

今天被complex<T>整了，1是对它不熟，2是模板报错乱七八糟


OkHttpUtils 关于response.body().byteStream()的坑
喜欢猪猪
10-30 4303
起因： OkHttpUtils类使用遇到的一个坑记录，在使用流文件的时候，不能进行两次的response.body().byteStream()，否则第二次调用该方法的时候流是关闭的，不能进行使用了； /** * post请求，返回InputStream * * @param url * @param json * @return * @throws IOException */ public InputStream postInputStream(String url, String json) thro
超级好用的C++实用库之字节流解析器
hope_wisdom的技术博客
04-20 1667
字节流解析器是一种软件组件，它负责将接收到的原始二进制数据（字节流）转换为有意义的信息结构或格式。在计算机网络、文件处理和数据通信中，字节流是最基本的数据传输形式，但这些原始字节对于应用程序通常是没有直接意义的，需要通过特定的解析规则来解读。在以下几种场景中，字节流解析器起着关键作用。网络通信：服务端接收到客户端发送过来的HTTP请求或响应时，其中包含了按照HTTP协议编码的字节流，解析器会将这些字节解码成请求头、请求体等可操作的对象。文件格式解析。
C++ 包装字节流
FUN
01-24 3433
学过 C++ 的人都知道 iostream，但是用流的方式来操作缓冲区好像不是那么简单。。 参考 std::streambuf::pubsetbuf 我们知道可以手动控制文件流的缓冲区大小： // set character buffer (pubsetbuf) #include &lt;fstream&gt; // std::fstream int main () { char ...
Java I/O -- Byte Stream
jvisualvm
06-30 221
Java I/O库的设计原则 • Java的I/O库提供了一个称做链接的机制，可以将一个流与另一个流首尾相接，形成一个流管道的链接。这种机制实际上是一种被称为Decorator(装饰)设计模式的应用。 • 通过流的链接，可以动态的增加流的功能，而这种功能的增加是通过组合一些流的基本功能而动态获取的。 • 我们要获取一个I/O对象，往往需要产生多个I/O对象，这也是Java I/O库不太容易掌...
Byte Streams
技术何
09-01 1087
Programs use byte streams to perform input and output of 8-bit bytes. All byte stream classes are descended from InputStream and OutputStream. There are many byte stream classes. To demonstrate how b
java stream byte_java学习-io-字节流(byteStream)
weixin_39612332的博客
02-21 327
对于程序而言,其使用字节流来操作 输出/输入 8位 的字节数据; 对于 java中所有的字节流操作实际都是基于 Input/OutputStream直接实现 :文件:java.io.FileInput/OutputStream数组:java.io.ByteArrayInput/OutputStream装饰器(decorate)模式实现缓冲:BufferedInput/OutputStream:提供...
Java byte stream 字节流
Regino的博客
03-12 3639
本文介绍了 Java 中 byte stream（字节流）的相关内容。。。
(CS144 2024)Lab Checkpoint 1: stitching substrings into a byte stream （详细解析）
2301_79140115的博客
04-28 716
[unassemble_index , capacity_index) 剩余的容量字节流区。* [unpopped_index , capacity_index] 总字节流区间。* [unpopped_index , unassemble_index）已经储存的区间。
ByteStream.js: 高效字节流处理库的介绍与应用
资源摘要信息:"ByteStream.js是一个JavaScript库，专注于提供字节流处理功能，特别是对字节和位的操作进行了优化，以便于实现快速的数据处理。ByteStream.js的核心是一个名为ByteStream的类，该类包含了对字节流进行...
ByteStream &data
06-03
"ByteStream &data" 这个表达式通常是指定义了一个名为"data"的引用，该引用指向一个名为"ByteStream"的类对象。引用是C++中一种特殊的变量，它不是实际存储数据的位置，而是另一个变量的别名，可以在程序中使用。这...
怎么使用response.body().byteStream() 读取数据
04-28
2. 调用 response.body().byteStream() 获取输入流。 3. 使用 Java I/O 流读取输入流中的数据。 4. 关闭输入流。 例如，以下代码展示了如何使用 response.body().byteStream() 读取网络图片： ``` Response ...
C++ 使用发stream文件流操作
12-02
使用fstream文件流的操作，实现一次性读取未知大小的文件，并实现内存与硬盘数据交换
Java——ByteStream字节流复制图片
qq_38454176的博客
01-17 366
需求： 把E:\hhh\mn.jpg复制到模块目录下的mn.jpg 思路： 1:根据数据源创建字节输入流对象 2:根据目的地创建字节输出流对象 3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组) 4:释放资源 public class CopyJpgDemo { public static void main(String[] args)...
如何用C++封装一个简单的数据流操作类（附源码），从而用于网络上的数据传输和解析？
lgsoftlee的博客
08-03 558
历史溯源 由于历史原因，我们目前看到的大部分的网络协议都是基于ASCII码这种纯文本方式，也就是基于字符串的命令行方式，比如HTTP、FTP、POP3、SMTP、Telnet等。早期操作系统UNIX(或DOS)，用户操作界面就是控制台，控制台的输入输出方式就决定了用户只能通过敲击键盘的方式将协议命令输入到网络，这也就导致了回车换行"\r\n"会作为一次命令结束的标识。 比如HTTP协议，与主机建立连接后，输入"GET / HTTP/1.1\r\n"即可获取网站的主页。 比如email协议，早期的电子邮件协议
Java中IO框架——ByteArrayOutputStream源码解析
在梅边的专栏
02-26 746
ByteArrayOutputStream 继承自 OutputStream 。 OutputStream 的源码分析见：http://blog.youkuaiyun.com/yx0628/article/details/79370689 同时可以参考 ByteArrayInputStream 的源码：http://blog.youkuaiyun.com/yx0628/article/details/79346595此
FFmpeg字节操作相关的源码：GetByteContext结构体，bytestream2_init、bytestream2_get_bytes_left、bytestream2_tell函数分析
崔杰城的博客
06-25 917
FFmpeg源码中使用GetByteContext结构体和相关的函数来对字节进行操作。比如FFmpeg按字节读取H.264码流时，会用到GetByteContext结构体，bytestream2_init、bytestream2_get_bytes_left、bytestream2_tell、bytestream2_skip等函数。
Java 流(Stream)--ByteStream
weixin_30485291的博客
04-16 576
package XXX; import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException; public class ByteStreamTest { public static void main(String args[]) throws IOExce...
文件读写
xiaoke5881037的专栏
06-14 489
  C++文本文件读写的方法 收藏 掌握文本文件读写的方法了解二进制文件的读写方法C++文件流：fstream　　// 文件流ifstream　 // 输入文件流ofstream　 // 输出文件流//创建一个文本文件并写入信息//同向屏幕上输出信息一样将信息输出至文件#include#includevoid main(){　　ofstream f1("d://me.txt");　　　　　　　　　　　//打开文件用于写，若文件不存在就创建它　　if(!f1)return;　　　　　　　　　　　　　　　　　/
【流 Stream】数据传输：字节流与字符流详解 文件读写必备基础知识！！！
hhw_hhw的博客
10-30 2061
在计算机编程中，流（stream）是一种抽象概念，用于表示数据在程序中的传输和处理方式。流可以看作是数据的通道，通过这个通道，数据可以按照特定的顺序从源头流向目的地。流主要用于解决数据传输和处理中的一些基本问题输入和输出：流提供了一种统一的方式来处理输入和输出。程序可以从输入流中读取数据，或将数据写入到输出流中。这使得程序可以与不同的数据源（如文件、网络、设备等）进行交互，而无需关心底层的细节。数据传输：流可以将数据分割成小的数据块（如字节或字符），并按照顺序逐个传输。
Byte Stream
最新发布
05-08
<think>好的，我现在需要回答用户关于字节流（Byte Stream）的概念和使用方法的问题。首先，我要确保自己正确理解字节流的基本定义。字节流是处理二进制数据的基本单位，每个字节由8位组成，可以表示0到255的数值。在编程中，字节流用于读取或写入二进制文件，比如图片、音频、视频等，或者进行网络数据传输。 接下来，用户可能想知道字节流与字符流的区别。字符流处理的是字符数据，通常是文本，而字节流处理的是原始二进制数据。字符流在底层实际上也是基于字节流实现的，但会处理字符编码（如UTF-8、GBK），将字节转换为字符。因此，在处理文本时，使用字符流更方便，而处理非文本数据时，必须使用字节流。 然后，我需要考虑如何在不同的编程语言中使用字节流。例如，在Java中，InputStream和OutputStream是处理字节流的基类，FileInputStream和FileOutputStream用于文件操作。Python中使用open函数以二进制模式（'rb'或'wb'）打开文件进行字节操作。C++中则使用std::ifstream和std::ofstream，并指定二进制模式（如ios::binary）。 用户可能还需要了解字节流的应用场景，比如文件传输、网络通信、加密解密等。例如，在发送文件时，将文件分割成字节流传输；加密算法处理的是字节数据；序列化对象时转换为字节流存储或传输。 此外，需要注意字节流的常见问题，比如正确处理大文件时的缓冲区使用，避免内存溢出；读取或写入时的异常处理，如文件不存在或权限问题；以及跨平台时的字节序（大端小端）问题。 最后，根据用户提供的引用，特别是引用[2]中提到数据流像水流，最小单位是字节或字符，这支持了字节流作为基本单位的解释。同时，引用[4]中的示例虽然处理的是字符数组，但可以类比到字节数组的操作，比如循环处理和条件判断，不过字节流更关注二进制数据的处理。 总结回答结构：先定义字节流，对比字符流，再分语言举例使用方法，接着应用场景和注意事项，最后相关问题。确保使用正确的LaTeX格式和引用标记。</think>### 字节流（Byte Stream）的概念与使用方法 #### 1. **概念定义** 字节流是编程中处理二进制数据的基本单位，以**单个字节（8位）**为最小处理单元，范围是$0 \leq \text{值} \leq 255$。它直接操作原始二进制数据，适用于非文本文件（如图像、音频、视频）或网络数据传输[^2]。 #### 2. **字节流 vs 字符流** - **字节流**：直接处理原始字节，不涉及编码转换（如Java的`InputStream`/`OutputStream`）。 - **字符流**：基于字节流，但会结合字符编码（如UTF-8）将字节转换为字符（如Java的`Reader`/`Writer`），适用于文本处理。 #### 3. **使用方法（以常见语言为例）** ##### **Java** ```java // 读取文件字节流 try (FileInputStream fis = new FileInputStream("image.jpg")) { int byteData; while ((byteData = fis.read()) != -1) { // 处理每个字节（例如加密、复制） } } // 写入字节流 try (FileOutputStream fos = new FileOutputStream("copy.jpg")) { byte[] buffer = new byte[1024]; int bytesRead; while ((bytesRead = fis.read(buffer)) != -1) { fos.write(buffer, 0, bytesRead); } } ``` ##### **Python** ```python # 读取二进制文件 with open("data.bin", "rb") as f: byte_data = f.read() # 返回bytes对象 # 处理字节数据（如解析结构体） # 写入二进制数据 with open("output.bin", "wb") as f: f.write(b'\x48\x65\x6c\x6c\x6f') # 写入字节序列 ``` ##### **C++** ```cpp #include <fstream> using namespace std; // 读取二进制文件 ifstream input("file.bin", ios::binary); char buffer[1024]; input.read(buffer, sizeof(buffer)); // 写入二进制数据 ofstream output("output.bin", ios::binary); output.write(buffer, input.gcount()); ``` #### 4. **应用场景** - **文件传输**：如通过HTTP发送图片或视频的字节数据。 - **网络通信**：TCP协议基于字节流传输（如Socket编程）。 - **加密/压缩**：AES加密、ZIP压缩均直接操作字节流。 - **序列化**：将对象转换为字节流存储（如Protobuf协议）。 #### 5. **注意事项** - **缓冲区管理**：大文件需分块读取（如Java的`BufferedInputStream`），避免内存溢出。 - **编码问题**：若误用字节流处理文本，可能导致乱码（如未正确解析UTF-8多字节字符）。 - **字节序（Endianness）**：跨平台传输时需统一多字节数据的顺序（如`int`类型）。 --- ###
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值