用C++实现Java的ByteArray类（字节数组）

最新推荐文章于 2024-07-29 08:30:00 发布
最新推荐文章于 2024-07-29 08:30:00 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ java C++实现字节数组类 C++仿Java字节数组类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jolin678/article/details/131755762
版权
文章介绍了一个C++实现的ByteArray类，包括添加、获取和设置字节，以及转换为不同格式字符串的功能。还展示了从字节字符串、二进制字符串和长整型创建ByteArray对象的方法，并提供了部分未实现的成员函数。在主函数中，展示了ByteArray对象的使用，如添加字节、转换为各种字符串、提取子字节字段和反向字节顺序等操作。
摘要由CSDN通过智能技术生成

最近由于项目原因，需要将Java项目中的ByteArray类用C++实现一遍，于是琢磨了一下，下面是该类中部分已实现方法的使用说明：

    // 添加一个字节到ByteArray中。
    void addByte(uint8_t byte);

    // 添加多个字节到ByteArray中
    void addBytes(const std::vector<uint8_t>& bytes) 

    // 获取指定索引位置的字节。
    uint8_t getByte(int index) const;

    // 设置指定索引位置的字节值。
    void setByte(int index, uint8_t value);

    //获取所有字节
    std::vector<uint8_t> getBytes();

    // 获取ByteArray的长度（字节数）。
    int length() const;

    // 从字节字符串创建一个ByteArray对象。
    static ByteArray fromByteString(const std::string& byteString);

    // 将ByteArray转换为二进制字符串。
    std::string toBinaryString() const;

    // 从二进制字符串创建一个ByteArray对象。
    static ByteArray fromBinaryString(const std::string& binaryString);

    // 从长整型值创建一个ByteArray对象。
    static ByteArray fromLongValue(uint64_t value);

    // 将ByteArray转换为ASCII字符串。
    std::string toASCII() const;

    // 从ByteArray中提取指定位范围的子字节字段。
    ByteArray subByteField(int startBit, int numBits) const;

    // 反转ByteArray中的字节顺序。
    void reverse();

下面几个是计划添加但还没实现的函数：

    // 获取ByteArray的字节数据。
    const std::vector<uint8_t>& getData() const;

    // 根据索引获取ByteArray的字节数据。
    uint8_t operator[](int index) const;

    // 根据索引设置ByteArray的字节数据。
    uint8_t& operator[](int index);

    // 比较两个ByteArray是否相等。
    bool operator==(const ByteArray& other) const;

    // 比较两个ByteArray是否不相等。
    bool operator!=(const ByteArray& other) const;

下面是完整的实现代码：


#include "stdafx.h"


#include <iostream>
#include <vector>
#include <stdexcept>
#include <sstream>
#include <iomanip>

class ByteArray {
private:
	std::vector<uint8_t> data;

public:
	ByteArray() {}

	ByteArray(const std::vector<uint8_t>& bytes) : data(bytes) {}

	void addByte(uint8_t byte) {
		data.push_back(byte);
	}

	void addBytes(const std::vector<uint8_t>& bytes) {
		data.insert(data.end(), bytes.begin(), bytes.end());
	}

	uint8_t getByte(int index) {
		if (index < 0 || index >= data.size()) {
			throw std::out_of_range("Index out of range");
		}
		return data[index];
	}

	void setByte(int index, uint8_t byte) {
		if (index < 0 || index >= data.size()) {
			throw std::out_of_range("Index out of range");
		}
		data[index] = byte;
	}

	int length() {
		return data.size();
	}

	std::vector<uint8_t> getBytes() {
		return data;
	}

	std::string toString() {
		std::string result(data.begin(), data.end());
		return result;
	}

	bool equals(const ByteArray& other) {
		if (data.size() != other.data.size()) {
			return false;
		}
		for (int i = 0; i < data.size(); i++) {
			if (data[i] != other.data[i]) {
				return false;
			}
		}
		return true;
	}

	static ByteArray fromByteString(const std::string& byteString) {
		std::vector<uint8_t> bytes;
		std::istringstream iss(byteString);
		std::string byte;

		while (iss >> std::setw(2) >> byte) {
			uint8_t value = std::stoi(byte, nullptr, 16);
			bytes.push_back(value);
		}

		return ByteArray(bytes);
	}

	static ByteArray fromBinaryString(const std::string& binaryString) {
		std::vector<uint8_t> bytes;
		std::string byte;

		for (int i = 0; i < binaryString.length(); i += 8) {
			byte = binaryString.substr(i, 8);
			uint8_t value = std::stoi(byte, nullptr, 2);
			bytes.push_back(value);
		}

		return ByteArray(bytes);
	}

	static ByteArray fromLongValue(uint64_t value) {
		std::vector<uint8_t> bytes(sizeof(value));
		for (int i = sizeof(value) - 1; i >= 0; i--) {
			bytes[i] = value & 0xFF;
			value >>= 8;
		}
		return ByteArray(bytes);
	}

	uint8_t get(int index) {
		return getByte(index);
	}

	void insertBits(int index, uint8_t value, int numBits) {
		if (index < 0 || index > length() || numBits < 0 || numBits > 8) {
			throw std::out_of_range("Index or number of bits out of range");
		}

		uint8_t currentByte = getByte(index);

		// Shift existing bits to the left
		currentByte <<= numBits;

		// Clear the space for new bits
		uint8_t mask = ~(0xFF << numBits);
		currentByte &= mask;

		// Insert the new bits
		value &= mask;
		currentByte |= value;

		setByte(index, currentByte);
	}

	uint8_t getBit(int index, int bitPosition) {
		if (index < 0 || index >= length() || bitPosition < 0 || bitPosition > 7) {
			throw std::out_of_range("Index or bit position out of range");
		}

		uint8_t currentByte = getByte(index);
		return (currentByte >> bitPosition) & 0x01;
	}

	std::string ByteArray::toByteString() {
		std::stringstream ss;
		ss << std::hex << std::setfill('0');

		for (int i = 0; i < length(); i++) {
			ss << std::setw(2) << static_cast<int>(data[i]) << " ";
		}

		std::string byteString = ss.str();

		// Remove trailing space
		byteString.pop_back();

		return byteString;
	}

	int size() {
		return length() * 8;
	}

	std::string toBinaryString() {
		std::stringstream ss;
		for (int i = 0; i < length(); i++) {
			uint8_t currentByte = getByte(i);
			for (int j = 7; j >= 0; j--) {
				ss << ((currentByte >> j) & 0x01);
			}
		}
		return ss.str();
	}

	uint64_t toLongValue() {
		if (length() > sizeof(uint64_t)) {
			throw std::out_of_range("ByteArray size too large for uint64_t conversion");
		}
		uint64_t value = 0;
		for (int i = 0; i < length(); i++) {
			value <<= 8;
			value |= getByte(i);
		}
		return value;
	}

	std::string toASCII() {
		std::string result = "";
		for (int i = 0; i < length(); i++) {
			char character = static_cast<char>(getByte(i));
			result += character;
		}
		return result;
	}

	ByteArray ByteArray::subByteField(int startBit, int numBits) {
		if (startBit < 0 || startBit >= size() || numBits < 1 || numBits > size() - startBit) {
			throw std::out_of_range("Invalid start bit or number of bits");
		}

		int startByte = startBit / 8;
		int startBitIndex = startBit % 8;

		int endBit = startBit + numBits - 1;
		int endByte = endBit / 8;
		int endBitIndex = endBit % 8;

		std::vector<uint8_t> subBytes;

		if (startByte == endByte) {
			uint8_t startByteValue = getByte(startByte);
			uint8_t mask = static_cast<uint8_t>((1 << numBits) - 1);
			uint8_t subByteValue = (startByteValue >> (8 - startBitIndex - numBits)) & mask;
			subBytes.push_back(subByteValue);
		}
		else {
			uint8_t startByteValue = getByte(startByte);
			uint8_t mask = static_cast<uint8_t>((1 << (8 - startBitIndex)) - 1);
			uint8_t subByteValue = (startByteValue >> (8 - startBitIndex)) & mask;
			subBytes.push_back(subByteValue);

			for (int i = startByte + 1; i < endByte; i++) {
				uint8_t byteValue = getByte(i);
				subBytes.push_back(byteValue);
			}

			uint8_t endByteValue = getByte(endByte);
			uint8_t mask2 = static_cast<uint8_t>((1 << (endBitIndex + 1)) - 1);
			uint8_t subByteValue2 = (endByteValue >> (8 - endBitIndex - 1)) & mask2;
			subBytes.push_back(subByteValue2);
		}

		return ByteArray(subBytes);
	}

	void reverse() {
		std::reverse(data.begin(), data.end());
	}

	void set(int index, uint8_t value) {
		setByte(index, value);
	}

	void setBit(int index, int bitPosition, uint8_t bitValue) {
		if (index < 0 || index >= length() || bitPosition < 0 || bitPosition > 7 || (bitValue != 0 && bitValue != 1)) {
			throw std::out_of_range("Index, bit position, or bit value out of range");
		}

		uint8_t currentByte = getByte(index);
		uint8_t mask = ~(0x01 << bitPosition);
		currentByte &= mask;
		currentByte |= (bitValue << bitPosition);
		setByte(index, currentByte);
	}
};

下面是使用示例：

int main() {
	ByteArray byteArray;

	byteArray.addByte(0x55);
	byteArray.addByte(0xAA);
	byteArray.addByte(0xFF);

	std::cout << "ByteArray as hex string: " << byteArray.toString() << std::endl;

	std::string byteString = byteArray.toByteString();
	std::cout << "ByteArray as byte string: " << byteString << std::endl;

	ByteArray byteArrayFromByteString = ByteArray::fromByteString(byteString);
	std::cout << "ByteArray from byte string: " << byteArrayFromByteString.toString() << std::endl;

	std::string binaryString = byteArray.toBinaryString();
	std::cout << "ByteArray as binary string: " << binaryString << std::endl;

	ByteArray byteArrayFromBinaryString = ByteArray::fromBinaryString(binaryString);
	std::cout << "ByteArray from binary string: " << byteArrayFromBinaryString.toString() << std::endl;

	uint64_t longValue = 0xFFAA55;
	ByteArray byteArrayFromLongValue = ByteArray::fromLongValue(longValue);
	std::cout << "ByteArray from long value: " << byteArrayFromLongValue.toString() << std::endl;

	std::string asciiString = byteArray.toASCII();
	std::cout << "ByteArray as ASCII string: " << asciiString << std::endl;

	std::cout << "ByteArray size: " << byteArray.length() << std::endl;

	ByteArray subBytes = byteArray.subByteField(4, 12);
	std::cout << "Sub-byte field: " << subBytes.toString() << std::endl;

	byteArray.reverse();
	std::cout << "Reversed ByteArray: " << byteArray.toString() << std::endl;

	byteArray.setByte(1, 0xBB);
	std::cout << "Updated ByteArray: " << byteArray.toString() << std::endl;

	byteArray.setBit(0, 2, 1);
	std::cout << "Updated ByteArray: " << byteArray.toString() << std::endl;

	return 0;
}

在主函数中，我们创建了一个 ByteArray 对象并执行了以下操作：

  • 向 ByteArray 对象中添加字节
  • 将 ByteArray 对象转换为十六进制字符串并输出
  • 将 ByteArray 对象转换为字节字符串并输出
  • 使用 fromByteString 方法将字节字符串转换回 ByteArray 对象并输出
  • 将 ByteArray 对象转换为二进制字符串并输出
  • 使用 fromBinaryString 方法将二进制字符串转换回 ByteArray 对象并输出
  • 使用 fromLongValue 方法将长整型值转换为 ByteArray 对象并输出
  • 将 ByteArray 对象转换为 ASCII 字符串并输出
  • 获取 ByteArray 对象的长度并输出
  • 从 ByteArray 对象中提取子字节字段并输出
  • 反转 ByteArray 对象的字节反序并输出
  • 更新 ByteArray 对象的字节值并输出
  • 更新 ByteArray 对象的特定位的值并输出

下面是执行结果： 

 

Allen Roson
关注
专栏目录
cocos2d-x与lua数据传输操作之C++版ByteArray
九天
02-28 2916
以前写过ActionScript3.0，里边有个ByteArray类对数据流进行操作，zeng'rong实现了lua版本的ByteArray，但由于自己项目网络socket通信都写在了C++端，而游戏UI逻辑等写在了LUA端，故自己写了C++版本的ByteArray类导出给lua使用。
jbytearray转c++byte数组
热门推荐
vrix的专栏
10-20 3万+
jbytearray转c++byte数组
C++标准模板（STL）-基本类型 - 字节类型 （std::byte）
最新发布
qq_40788199的博客
07-29 929
std::byte 是一种独立类型，它实现指定于 C++ 语言定义中的字节的概念。 同 char 与 unsigned char ，它能用于访问其他对象所占据的生内存（对象表示），但不同于这些类型，它不是字符类型且非算术类型。 byte 只是位的汇集，而且只对它定义逐位运算符。
C/C++输出字节数组
tataoto的博客
07-08 1万+
C/C++输出字节数组C/C++输出字节数组1. C2. C++3.完整代码4.输出结果 C/C++输出字节数组 作为一个c++初学者，输出一个字节数组的方法让我找了半天，，，， 1. C 因为这里的 byte 我前面定义为 unsigned char ，即为8位，一个字节。 所以 buffer[] 为一个字符数组。 c直接使用printf 输出即可，具体几进制直接换%后的字母即可，又快又省事！ 再看c++吧，， 2. C++ 感觉C++的输出好麻烦，， 首先按照几进制输出得在前面写出来一个 cout &l
C/C++开发，无可避免的字符串（篇一）.字节数组
技术需要分享
03-25 1320
C/C++开发，无可避免的字符串（篇一）.字节数组。标准库实现字符串功能主要是通过类似于std::vector容器的std::basic_string类模板实现的，该模板提供了针对各种字符型号的特化类，如using std::string = std::basic_string;博文还阐述了std::basic_string—_view、空终止字节字符串、空终止宽字符串、空终止多字节字符串等功能函数集，并给出演示代码。
java byte数组转short数组
www09086031的博客
01-18 4185
https://www.cnblogs.com/wikiki/p/5340925.html
十六进制与字节数组转换
小黄狗的博客
05-30 7284
前段时间开发手持机上的软件，因为A8手持机的射频卡可存储的内容太小，并且需要存储16进制数据，因此就写了一个工具类。上代码：package cn.com.szh;import java.io.UnsupportedEncodingException;public class Main {    public static void main(String[] args) {        Stri...
Java字节数组打印：性能对比分析与优化选择
![java print byte array]...当调用该方法打印字节数组时，Java虚拟机会将字节数组转换为字符串，转换过程中使用了平台默认的字符编码。 ## 1.
Java性能优化秘传：字节数组打印的10大优化技巧
在当今高速发展的IT行业，Java作为一门成熟且广泛使用的编程语言，在应用过程中对其性能的优化显得尤为重要。Java性能优化涉及到的应用场景广泛，包括但不限于垃圾回收（GC）调优、代码级优化、类加载机制优化等。本...
unity向android传递数组,将字节数组从Unity传递到Android（C ++）进行修改
weixin_42200791的博客
05-27 813
我正在尝试使用本机库来修改字节数组(实际上是uint16数组)的内容。我在Unity(C＃)中具有数组，在C ++中具有本机库。我尝试了几件事，我能做的最好的事情就是成功调用本机代码并能够将布尔值返回给C＃。当我在C ++中传递数组并将其变异时，问题就来了。不管我做什么，该数组在C＃中都保持不变。这是我在Unity方面拥有的东西：// In Update().using (AndroidJavaC...
如何优雅的写C++代码 Obotcha介绍(ByteArray类)
一个白馒头的专栏
05-13 1789
C/C++中分配内存主要使用的就是mallc和new，但是如果随意申请内存，就无法做到自动回收。所以在Obotcha中，使用了一个ByteArray的类来管理内存。申请一段内存可以使用直接调用createByteArray(int size)接口来获取。ByteArray构造函数内部处理如下： _ByteArray::_ByteArray(int length) { buff ...
C++笔记之字节数组的处理
小勇博客
08-12 1810
二进制字节流是由一系列字节组成的数据流，其中每个字节可以取0到255范围内的整数值。字节数组可以存储任意类型的字节数据，包括文本字符、整数、二进制数据等。字节数组可以用于处理通用的二进制数据，例如在网络通信、文件IO、数据序列化和反序列化等方面。在此示例中，我们将一个字节数组写入一个二进制文件中，形成了一个二进制字节流。总之，字节数组适用于处理通用的二进制数据，而字符数组主要用于处理文本数据。字节数组和二进制字节流都是用于存储和处理字节数据的概念，但它们可能在上下文中有不同的含义。在C++中，通常使用。
c++字节数组的长度_C/C++ | 不会吧，柔性数组下篇真的来了
weixin_35353583的博客
01-30 195
摘要：在《C/C++ | 不会吧，不会吧，不会真的有人不知道柔性数组吧》总结中，通过比较定长数组，指针以及柔性数组之间的用法差异和优缺点来引入柔性数组的概念以及使用方法，本文承接上文，以问题的方式来理深入理解柔性数组。关于构造函数的认知误区问题 1：0长数组有什么好处❓正解：结构体最后使用0或1的长度数组的原因，主要是为了方便的管理内存缓冲区，如果你直接使用指针而不使用数组，那么，你在分...
数据结构动态分配空间 c++_你需要知道的那些 redis 数据结构（前篇）
weixin_39573535的博客
11-21 130
作者 | 饿了么物流技术团队来源 | CSDN 企业博客redis 对于团队中的同学们来说是非常熟悉的存在了，我们常用它来做缓存、或是实现分布式锁等等。对于其 api 中提供的几种数据结构，大家也使用得得心应手。api 中的数据结构有：string、list、hash、set、sorted set。这些 api 提供的“数据结构”，在 redis 的官方文档中有详细的介绍。就不多做展开，本次重点在...
Java笔记（14）-字节数组（ByteArray）流
孤独的狂欢
04-25 5347
与之前的文件流不同，之前的所有文件流，读取文件的位置，也就是源，其实都是在磁盘之中，Java无法直接访问，是需要通过操作系统的帮助才行；但是ByteArray不一样，他就叫字节数组，可以说是另外一个地方的某个内存数据； jvm虚拟机只能访问内存数据，字节数组就是一些重要的内存数据（二进制），使用Java操作这一组二进制流时，就是使用字节数组流的方式操作；更重要的是数据（如字符串等）都可以转化成...
C++ 字节数组的转换（C++编程思想-数据抽象例子分析）
追求真理
12-11 2602
C++编程思想，在介绍数据封装给了一个CStash的例子，大概的思想是，建立一个struct，来管理一个动态增长的数组。这个数组可以接受任何类型的基本数据类型。包括示例中的int和char，一个能保存多种数据类型的底层数据类型，当然是最小的类型也就是sizeof运算符返回为1的数据类型，综合考虑，原书中给出的unsigned char作为最基本的数据类型。实际上对应于标准的字节数组。对于这个转化过
Java的byte数组
wjy320的专栏
01-06 291
　　今天我们讨论一下Java的byte数组。byte数组就是字节数组，每一位存一个字节。看下面程序，猜猜输出多少？ package com.wjy.bytes; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOE...
C++中类型、数组、结构体、类所占字节数
billy的博客
03-28 3341
作者：billy 版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处 前言 在考虑内存管理之前，我们要先知道资源所占的内存大小。博主在这里整理了一些基础元素所占的字节大小，防止长时间不接触而遗忘掉。 ...
c++用unicode编码将字节数组转化成string类型
06-02
在C++中，可以使用`wstring`类型来存储Unicode编码的字符串。要将字节数组转换为`wstring`类型，可以使用MultiByteToWideChar函数。 以下是一个将字节数组转换为`wstring`类型的示例代码： ```cpp #include #...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Allen Roson

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值