数据、数组转为特定64字符串

已于 2023-03-06 17:13:20 修改
阅读量188 收藏
点赞数
文章标签： c++ c语言
于 2023-02-17 17:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lenkco/article/details/129091333
版权

 主要是防止“iIlLoO0”在不同字体显示时做不是错，将其转为"<@#$%&*>"从而方便人员识别；

QT SDK 部份

//const char alphabet_base64[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
//                               "ghijklmn" "opqrstuv" "wxyz0123" "456789+/";
//const char alphabet_base64url[] = "ABCDEFGH" "IJKLMNOP" "QRSTUVWX" "YZabcdef"
//                                  "ghijklmn" "opqrstuv" "wxyz0123" "456789-_";
static const char *__replaceCheckChar[]={"iIlLoO0\0","[@#$%&,]\0"};
#define _D_CHECK_CHAR_REPLACE( byte, before, after ) \
    if( !byte.isEmpty() ) \
    for( int i = 0 ; before[i]!='\0' && after[i]!='\0'; i++ ) \
    byte.replace( before[i], after[i] );
#define _D_BASE_CHAR_REPLACE(src) _D_CHECK_CHAR_REPLACE( src, __replaceCheckChar[0],__replaceCheckChar[1] ); src.push_front(':')
#define _D_BASE_CHAR_RESUME(src) if( !src.isEmpty() && src[0]==':' ) {src.remove(0,1); _D_CHECK_CHAR_REPLACE( src, __replaceCheckChar[1],__replaceCheckChar[0] );}

 以下是测试为其他 IDE SDK与编写

#include <QCoreApplication>


#include <qdebug.h>

///数据转字符串

const char *_const_10tune64 = "0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz@#$%";
const char *_10tune64_20 = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz@#=%!,;+-";
unsigned char _64tune10_20[256] = {
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0x3B, 0xFF, 0x38, 0xFF, 0x3A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0x3C, 0x3F, 0xFF, 0xFF,
    0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xFF, 0x3D, 0xFF, 0x39, 0xFF, 0xFF,
    0x37, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0x10, 0x11, 0x12, 0x13, 0x14, 0xFF,
    0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0xFF, 0x28, 0x29, 0xFF, 0x2A, 0x2B, 0xFF,
    0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

const unsigned char _64tune10A_20[] = {
    0xFF, 0x3B, 0xFF, 0x38, 0xFF, 0x3A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0x3C, 0x3F, 0xFF, 0xFF,
    0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xFF, 0x3D, 0xFF, 0x39, 0xFF, 0xFF,
    0x37, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0x10, 0x11, 0x12, 0x13, 0x14, 0xFF,
    0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0xFF, 0x28, 0x29, 0xFF, 0x2A, 0x2B, 0xFF,
    0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

const uchar _const_64tune10[256] = {
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,61,62,63,255,255,255,255,255,255,255,255,
    255,255,0,1,2,3,4,5,6,7,8,9,255,255,255,255,255,255,60,10,11,
    12,13,14,15,16,17,18,19,20,21,22,23,255,24,25,26,27,28,29,30,
    31,32,33,34,255,255,255,255,255,255,35,36,37,38,39,40,41,42,
    43,44,45,255,46,47,48,49,50,51,52,53,54,55,56,57,58,59,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
    255,255,255,255,255,255,255,255,255,255,255,255 };


static uchar *const_64tune10 =(uchar *)_64tune10_20;
static uchar *const_10tune64 =(uchar *)_10tune64_20;

// makeDecode生成解释特定字串的数组
void makeDecode( unsigned char *_64tune10,
                 unsigned char size,
                 const unsigned char _10tune64_20[64] )
{
    memset( _64tune10, 0xff, size );

    for(int k=0;k<64;k++)
    {
        _64tune10[ _10tune64_20[k] ]=(unsigned char)k;
    }

    //    QString str("const unsigned char _64tune10_20[256] = {");
    //    for(int i=0;i<256;i++)
    //    {
    //        if( i%16==0 )
    //            str+="\n";
    //        str+=QString::asprintf("0x%0.2X, ", _64tune10[i]);

    //    }
    //    str+="};\n\n";
    //    qDebug()<<str;
}

// tByteTo64 将2进制数据转特定字符串
inline std::string tByteTo64( const int8_t* dat, const int size ) // 2进制转64
{
    std::string str;
    uint16_t val;
    uint8_t *p=(uint8_t*)dat;
    uint16_t ch=0;

    for ( int count_ch=0,count_bit=0; count_ch<size || ch>0; )
    {
        if(count_ch<size && count_bit<6)
        {
            val = p[count_ch];
            ch |= val<<count_bit;
            count_bit+=8;
        }

        str.push_back( const_10tune64[ch & 0x3f] );
        ch>>=6;
        count_bit-=6;
        if(count_bit<6) count_ch++;
    }

    return str;
}
inline std::string tByteTo64( std::vector<int8_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()) );
}
inline std::string tByteTo64( std::vector<uint8_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()) );
}
inline std::string tByteTo64( std::vector<int16_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*2) );
}
inline std::string tByteTo64( std::vector<uint16_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*2) );
}
inline std::string tByteTo64( std::vector<int32_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*4) );
}
inline std::string tByteTo64( std::vector<uint32_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*4) );
}
inline std::string tByteTo64( std::vector<int64_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*8) );
}
inline std::string tByteTo64( std::vector<uint64_t> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*8) );
}
inline std::string tByteTo64( std::vector<float> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*4) );
}
inline std::string tByteTo64( std::vector<double> dat ){
    return tByteTo64( (const int8_t*) dat.data(), (const int) (dat.size()*8) );
}
inline std::string tByteTo64( uint8_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( int8_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( uint16_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( int16_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( uint32_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( int32_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( uint64_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( int64_t dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( float dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}
inline std::string tByteTo64( double dat ){
    return tByteTo64( (const int8_t*) &dat, (const int) sizeof(dat) );
}

// t64ToByte 将特定字符串转为2进制数据
bool t64ToByte( const std::string p , char* dat, int &len )//64进制转2
{
    int iSize=len;
    int i=0;
    qint16 j=0;
    int val=0;
    int size = p.size();
    int k=0;
    len=0;
    for ( ; i<size && len<iSize; i++ )
    {
        j = (uchar)const_64tune10 [ p.at(i) ];
        if ( j == 255 )
        {
            len=-1;
            return false;
        }
        val |= (j<<(k));
        k+=6;
        for( ; k>=8 && len<iSize; )
        {
            dat[ len++ ]=val&0xff;
            val>>=8;
            k-=8;
        }
    }
    len++;
    return true;
}

#define _D_64TO_BYTE_VECTOR_HELPER( ty ) \
    int si=p.size()*6; \
    int len = (si/8)+(si%8!=0? 1:0); \
    char* data=new char[ len ]; \
    ty *pd=( ty *)data; \
    bool ok = t64ToByte( p, (char*) data, len );  \
    if(ok) { \
    for( int i=0,j=len/sizeof(ty); i<j; i++ ) \
    dat.push_back( pd[i]); } \
    return ok;

#define _D_64TO_BYTE_HELPER( ) \
    int len=sizeof(dat); \
    bool ok = t64ToByte( p, (char*) &dat, len ); \
    return ok;

inline bool t64ToByte( const std::string p , std::vector<int8_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( int8_t );
}
inline bool t64ToByte( const std::string p , std::vector<uint8_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( uint8_t );
}
inline bool t64ToByte( const std::string p , std::vector<int16_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( int16_t );
}
inline bool t64ToByte( const std::string p , std::vector<uint16_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( uint16_t );
}
inline bool t64ToByte( const std::string p , std::vector<int32_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( int32_t );
}
inline bool t64ToByte( const std::string p , std::vector<uint32_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( uint32_t );
}
inline bool t64ToByte( const std::string p , std::vector<int64_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( int64_t );
}
inline bool t64ToByte( const std::string p , std::vector<uint64_t> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( uint64_t );
}
inline bool t64ToByte( const std::string p , std::vector<float> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( float );
}
inline bool t64ToByte( const std::string p , std::vector<double> &dat ){
    _D_64TO_BYTE_VECTOR_HELPER( double );
}
inline bool t64ToByte( const std::string p , uint8_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , int8_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , uint16_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , int16_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , uint32_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , int32_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , uint64_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , int64_t &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , float &dat ){
    _D_64TO_BYTE_HELPER();
}
inline bool t64ToByte( const std::string p , double &dat ){
    _D_64TO_BYTE_HELPER();
}





// t64ToByte 将特定字符串转为2进制数据
bool t64ToByte( const QByteArray p , QByteArray &dat  )//64进制转2
{
    int i=0;
    qint16 j=0;
    int val=0;
    int size = p.size();//419d747fe0000000
    int k=0;
    for ( ; i<size  ; i++ )
    {
        j = (uchar)const_64tune10 [ p.at(i) ];
        if ( j == 255 )
        {
            dat.clear();
            return false;
        }
        val |= (j<<(k));
        k+=6;
        for( ; k>=8 ; )
        {
            dat.append( val&0xff );
            val>>=8;
            k-=8;
        }
    }

    return true;
}
// tByteTo64 将2进制数据转特定字符串
QByteArray tByteTo64( const QByteArray dat ) // 2进制转64
{
    int size = dat.size() ;
    QByteArray str;
    uint16_t val;
    uint8_t *p = (uint8_t*)dat.data();
    int  j=0;
    uint16_t ch=0;

    for ( int c=0,bi=0;c<size || ch>0; )
    {
        if(c<size && bi<6)
        {
            val=p[c];
            ch|=val<<bi;
            bi+=8;
        }

        j = ch & 0x3f;
        str.push_back( const_10tune64[j]);
        ch>>=6;
        bi-=6;
        if(bi<6)c++;
    }

    return str;
}
// t64ToByte 将特定字符串转为2进制数据
QByteArray t64ToByte( const QByteArray p )//64进制转2
{
    QByteArray dat;
    bool ok=t64ToByte( p , dat  );
    return dat;
}


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    makeDecode( const_64tune10, 256, const_10tune64 );

    std::vector<int64_t> dat,dat2;
    int k=0;
    for( int i=0; i<100; i++ ) {
        k = qrand()*100;
        dat.push_back(k);
    }
    std::string str = tByteTo64( dat );
    qDebug()<<__LINE__<< str.data()<< str.size()<<(str.size()*6/8)+(str.size()*6%8!=0? 1:0);
    qDebug()<<__LINE__<< t64ToByte( str , dat2 );

    for(int i=0;i<100;i++){
        qDebug()<<__LINE__<<"\t\t"<<i<<"\t\t"<< dat.at(i)<<"\t\t"<< dat2.at(i)<<"\t\t"<<(dat.at(i) - dat2.at(i));
    }



    return a.exec();
}

lenkco
关注
将8位的有符号数强转64位的无符号数的坑
anliayx的博客
04-23 1544
今天在做公司大数据分析时遇到个坑，某些数据莫名其妙变得特别大： 最终定位出原因在这个强转这里当8位有符号数扩展为64位无符号数时，底层汇编实际上使用的是movsx带符号扩展指令，意思就是扩展的那些位都用符位来补全，这里就造成了value的高58位全为1，从而值异常大。我们再来做个简单测试：-29和157的二进制是一样的10011101，为何强转后的值不一样，原因在于计算机内存负数的方式为补码，所以...
JS将数组转换为分隔字符串
hzw的博客
09-08 3570
JS将数组转换为分隔字符串 将数组 [‘red’, ‘green’, ‘blue’, ‘pink’] 转换为字符串，并且用 | 或其他符号分割 1.需要一个新变量用于存放转换完的字符串 str。 2.遍历原来的数组，分别把里面数据取出来，加到字符串里面。 代码示例： <script> var arr = ['red', 'green', 'blue', 'pink']; var str = ''; var sep = '|'; for (var i = 0; i < arr.l
JavaScript 使用newArray()替换Uint8Array(),Uint16Array(),Uint64Array(),Float64Array()等方法
qq_39495727的博客
04-11 2139
使用newArray()替换Uint8Array(),Uint16Array(),Uint64Array(),Float64Array()等方法 .subarray()使用 .slice() 替换 经过测试有效 function newArray(e){ t = [] //debugger if (e.constructor == Array){ for (var n = 0; n < e.length; n++) t.push(
C++类型转换
WX_Chen的博客
12-09 694
int转换为string to_string函数 https://blog.csdn.net/chavo0/article/details/51038397 int转换为char itoa char转换为int atoi string转换为int stoi string转换成char*字符串 string str="adcd"; char *p=(char*)str.c_str(); https://blog.csdn.net/sunshihua12829/article/details/48003
把字符串数字转成uint64_t类型
waboy_zhao的专栏
11-02 5218
把字符串数字转成uint64_t类型 #include #include #include #include using namespace std; int main(int argc, char **argv) {      if (argc     {         cerr         return -1;     } cout
char类型转换为uint32_t/uint16_t/uint8_t/void*类型再分析
modi000的博客
08-22 1万+
我们在该文中已经分析了关于字符指针强制类型转换为uint16_t/uint8_t型指针，不会越限的现象，这里我们做一下具体分析： char ch[4]={0xAA,0x11}; printf("%d %d\n",*ch,*(ch+1)); printf("%x %x\n",*ch,*(ch+1)); printf("uint8_t:%d %d\n",*(uint8_t*)ch,*(uint8_t*)(ch+1));//十进制 printf("uint8_t:
JS实现将二维数组转为json格式字符串操作示例
10-18
在当今Web开发中，将二维数组转换为JSON格式字符串是一种常见的数据处理需求。在JavaScript中，这种转换可以通过数组遍历、拼接和转换操作来实现。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，...
JS字符串和数组如何实现相互转化
11-20
在JavaScript（JS）中，字符串和数组是两种非常常见的数据类型。它们各有其特定的用途，但有时我们需要在两者之间进行转化，以便更好地处理数据。本文将深入探讨如何使用JS中的方法将字符串转换为数组，以及如何将...
字符串和数组的转化
11-05
- 数据处理：数组运算通常比字符串操作更为高效，因此在进行大量计算时，可能会选择先将字符串转为数组，进行计算后再转回字符串。 在使用这两个VI时，需要注意以下几点： - 分隔符：在`string to array.vi`中，...
Thymeleaf显示base64字符串为图片.docx
03-12
在网页开发中，有时我们需要将Base64编码的字符串直接作为图片显示出来，这在Thymeleaf框架中可以通过特定的方式实现。Base64是一种数据编码方式，它将二进制数据转化为可打印的ASCII字符，常用于在HTTP协议中传输...
字符串向 unsigned long long 64位转换
utopia的专栏
08-02 2万+
<br />最近在linux下用到uint64_t类型，需要存储长达20位的ID号，需要用到类型转换。<br />从字符串到uint64_t转换，想到了atoi,atol,atoll,strtol,结果发现18446744073709551616全被截断了。<br />(unsigned long long)atoll(18446744073709551616); 这个肯定是不行的。<br /> <br />后面用到了stringstream 才把问题解决，包含头文件<sstream><br /> <br
uint64 和字符串相互转换
热门推荐
xiaodoubao124的专栏
08-07 2万+
uint64转换成string snprintf函数声明int snprintf(char *restrict buf, size_t n, const char * restrict format, ...);例如：snprintf(string,sizeof(string),"%ju",GID);string转换成uint64GID=strtoull(pszValue, NULL, 0);
浅析C语言之uint8_t / uint16_t / uint32_t /uint64_t
梦心之魂的博客
07-02 1768
一、C语言基本数据类型回顾 在C语言中有6种基本数据类型：short、int、long、float、double、char 1、数值类型 1)整型：short、int、long 2)浮点型：float、double 2、字符类型：char 二、typedef回顾 typedef用来定义关键字或标识符的别名，例如： typedef double wages; typedef wages sa...
c/c++字节序转换（转）
weixin_30634661的博客
01-18 794
字节序（byte order）关系到多字节整数（short/int16、int/int32,int64）和浮点数的各字节在内存中的存放顺序。字节序分为两种：小端字节序（little endian）和大端字节序（bigendian）。小端字节序：低字节存放在内存低地址，例如对两字节整数0x0100(十进制数256)，低字节00放在低地址（假设地址为0x0041f880），高字节01放在高地址0x0...
c++ string和其他类型互转
zyc2018的博客
03-11 1739
C++数值类型与string的相互转换：https://www.cnblogs.com/johngu/p/7878029.html C++ string的万能转换，从long string 之间的转换来看看：https://blog.csdn.net/Vic___/article/details/9324897 c++11 头文件<string> 头文件<sstream&...
C语言输出uint64_t和uint32_t、64位整型和字符串转换
hwh20095000060的专栏
08-05 1万+
3、其中64位无符号数，typedef unsigned long long int uint64_t;1、输出uint32_t 的数值。2、输出uint64_t 的数值。
C语言编程 8字节的数据转换为uint64_t类型数据
professionalmcu的专栏
06-24 4547
有2种方式可以实现： 第一种方式： 数据类型强制转换，需要注意平台是大端还是小端,如果平台是大端，那么字节数组存放的字节顺序是高字节在前；如果平台是小端，那么字节数组存放的字节顺序是低字节在前。 此例程需要在小端模式的平台上运行 /** * @brief None * @param None * @retval None */ int main( void ) { uint8_t ByteDatasLittleEnd[8] = {0x06, 0x4E, 0xE7, 0.
如何将数组转为字符串
最新发布
10-09
1. 使用循环遍历数组中的元素，将每个元素转换为字符串，并使用特定字符（如逗号、空格等）连接它们。例如，在Python中，可以使用join方法来实现： ```python array = [1, 2, 3, 4, 5] string = ', '.join(str(x) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值