android byte转string_我擦～字符串转字节切片后，切片的容量竟然千奇百怪

最新推荐文章于 2022-08-25 10:49:35 发布
最新推荐文章于 2022-08-25 10:49:35 发布
阅读量119 收藏
点赞数
文章标签： android byte转string arduino byte转string byte 转string byte转string byte转string乱码 c++ builder byte 转字符串

神奇的现象

切片， 切片， 又是切片!

前一篇文章讲的是切片， 今天遇到的神奇问题还是和切片有关， 具体怎么个神奇法， 我们来看看下面几个现象

现象一

a := "abc"
bs := []byte(a)
fmt.Println(bs, len(bs), cap(bs))
// 输出： [97 98 99] 3 8

现象二

a := "abc"
bs := []byte(a)
fmt.Println(len(bs), cap(bs))
// 输出: 3 32

现象三

bs := []byte("abc")
fmt.Println(len(bs), cap(bs))
// 输出: 3 3

现象四

a := ""
bs := []byte(a)
fmt.Println(bs, len(bs), cap(bs))
// 输出: [] 0 0

现象五

a := ""
bs := []byte(a)
fmt.Println(len(bs), cap(bs))
// 输出: 0 32

分析

到这儿我已经满脑子问号了

fc108f2a6b43e7d0084835d1ff7ddfab.png

字符串变量转切片

一个小小的字符串转切片， 内部究竟发生了什么， 竟然如此的神奇。 这种时候只好祭出前一篇文章的套路了， 看看汇编代码(希望之后有机会能够对go的汇编语法进行简单的介绍)有没有什么关键词能够帮助我们

以下为现象一转换的汇编代码关键部分

"".main STEXT size=495 args=0x0 locals=0xd8
    0x0000 00000 (test.go:5)    TEXT    "".main(SB), ABIInternal, $216-0
    0x0000 00000 (test.go:5)    MOVQ    (TLS), CX
    0x0009 00009 (test.go:5)    LEAQ    -88(SP), AX
    0x000e 00014 (test.go:5)    CMPQ    AX, 16(CX)
    0x0012 00018 (test.go:5)    JLS 485
    0x0018 00024 (test.go:5)    SUBQ    $216, SP
    0x001f 00031 (test.go:5)    MOVQ    BP, 208(SP)
    0x0027 00039 (test.go:5)    LEAQ    208(SP), BP
    0x002f 00047 (test.go:5)    FUNCDATA    $0, gclocals·7be4bbacbfdb05fb3044e36c22b41e8b(SB)
    0x002f 00047 (test.go:5)    FUNCDATA    $1, gclocals·648d0b72bb9d7f59fbfdbee57a078eee(SB)
    0x002f 00047 (test.go:5)    FUNCDATA    $2, gclocals·2dfddcc7190380b1ae77e69d81f0a101(SB)
    0x002f 00047 (test.go:5)    FUNCDATA    $3, "".main.stkobj(SB)
    0x002f 00047 (test.go:6)    PCDATA  $0, $1
    0x002f 00047 (test.go:6)    PCDATA  $1, $0
    0x002f 00047 (test.go:6)    LEAQ    go.string."abc"(SB), AX
    0x0036 00054 (test.go:6)    MOVQ    AX, "".a+96(SP)
    0x003b 00059 (test.go:6)    MOVQ    $3, "".a+104(SP)
    0x0044 00068 (test.go:7)    MOVQ    $0, (SP)
    0x004c 00076 (test.go:7)    PCDATA  $0, $0
    0x004c 00076 (test.go:7)    MOVQ    AX, 8(SP)
    0x0051 00081 (test.go:7)    MOVQ    $3, 16(SP)
    0x005a 00090 (test.go:7)    CALL    runtime.stringtoslicebyte(SB)
    0x005f 00095 (test.go:7)    MOVQ    40(SP), AX
    0x0064 00100 (test.go:7)    MOVQ    32(SP), CX
    0x0069 00105 (test.go:7)    PCDATA  $0, $2
    0x0069 00105 (test.go:7)    MOVQ    24(SP), DX
    0x006e 00110 (test.go:7)    PCDATA  $0, $0
    0x006e 00110 (test.go:7)    PCDATA  $1, $1
    0x006e 00110 (test.go:7)    MOVQ    DX, "".bs+112(SP)
    0x0073 00115 (test.go:7)    MOVQ    CX, "".bs+120(SP)
    0x0078 00120 (test.go:7)    MOVQ    AX, "".bs+128(SP)

以下为现象二转换的汇编代码关键部分

"".main STEXT size=393 args=0x0 locals=0xe0
    0x0000 00000 (test.go:5)    TEXT    "".main(SB), ABIInternal, $224-0
    0x0000 00000 (test.go:5)    MOVQ    (TLS), CX
    0x0009 00009 (test.go:5)    LEAQ    -96(SP), AX
    0x000e 00014 (test.go:5)    CMPQ    AX, 16(CX)
    0x0012 00018 (test.go:5)    JLS 383
    0x0018 00024 (test.go:5)    SUBQ    $224, SP
    0x001f 00031 (test.go:5)    MOVQ    BP, 216(SP)
    0x0027 00039 (test.go:5)    LEAQ    216(SP), BP
    0x002f 00047 (test.go:5)    FUNCDATA    $0, gclocals·0ce64bbc7cfa5ef04d41c861de81a3d7(SB)
    0x002f 00047 (test.go:5)    FUNCDATA    $1, gclocals·00590b99cfcd6d71bbbc6e05cb4f8bf8(SB)
    0x002f 00047 (test.go:5)    FUNCDATA    $2, gclocals·8dcadbff7c52509cfe2d26e4d7d24689(SB)
    0x002f 00047 (test.go:5)    FUNCDATA    $3, "".main.stkobj(SB)
    0x002f 00047 (test.go:6)    PCDATA  $0, $1
    0x002f 00047 (test.go:6)    PCDATA  $1, $0
    0x002f 00047 (test.go:6)    LEAQ    go.string."abc"(SB), AX
    0x0036 00054 (test.go:6)    MOVQ    AX, "".a+120(SP)
    0x003b 00059 (test.go:6)    MOVQ    $3, "".a+128(SP)
    0x0047 00071 (test.go:7)    PCDATA  $0, $2
    0x0047 00071 (test.go:7)    LEAQ    ""..autotmp_5+64(SP), CX
    0x004c 00076 (test.go:7)    PCDATA  $0, $1
    0x004c 00076 (test.go:7)    MOVQ    CX, (SP)
    0x0050 00080 (test.go:7)    PCDATA  $0, $0
    0x0050 00080 (test.go:7)    MOVQ    AX, 8(SP)
    0x0055 00085 (test.go:7)    MOVQ    $3, 16(SP)
    0x005e 00094 (test.go:7)    CALL    runtime.stringtoslicebyte(SB)
    0x0063 00099 (test.go:7)    MOVQ    40(SP), AX
    0x0068 00104 (test.go:7)    MOVQ    32(SP), CX
    0x006d 00109 (test.go:7)    PCDATA  $0, $3
    0x006d 00109 (test.go:7)    MOVQ    24(SP), DX
    0x0072 00114 (test.go:7)    PCDATA  $0, $0
    0x0072 00114 (test.go:7)    PCDATA  $1, $1
    0x0072 00114 (test.go:7)    MOVQ    DX, "".bs+136(SP)
    0x007a 00122 (test.go:7)    MOVQ    CX, "".bs+144(SP)
    0x0082 00130 (test.go:7)    MOVQ    AX, "".bs+152(SP)

在看汇编代码之前， 我们首先来看一看runtime.stringtoslicebyte的函数签名

func stringtoslicebyte(buf *tmpBuf, s string) []byte

到这里只靠关键词已经无法看出更多的信息了,还是需要稍微了解一下汇编的语法,笔者在这里列出一点简单的分析， 之后我们还是可以通过取巧的方法发现更多的东西

// 现象一给runtime.stringtoslicebyte的传参
0x002f 00047 (test.go:6)    LEAQ    go.string."abc"(SB), AX // 将字符串"abc"放入寄存器AX
0x0036 00054 (test.go:6)    MOVQ    AX, "".a+96(SP) // 将AX中的内容存入变量a中
0x003b 00059 (test.go:6)    MOVQ    $3, "".a+104(SP) // 将字符串长度3存入变量a中
0x0044 00068 (test.go:7)    MOVQ    $0, (SP) // 将0 传递个runtime.stringtoslicebyte(SB)的第一个参数(笔者猜测对应go中的nil)
0x004c 00076 (test.go:7)    PCDATA  $0, $0 // 据说和gc有关， 具体还不清楚， 一般情况可以忽略
0x004c 00076 (test.go:7)    MOVQ    AX, 8(SP) // 将AX中的内容传递给runtime.stringtoslicebyte(SB)的第二个参数
0x0051 00081 (test.go:7)    MOVQ    $3, 16(SP) // 将字符串长度传递给runtime.stringtoslicebyte(SB)的第二个参数
0x005a 00090 (test.go:7)    CALL    runtime.stringtoslicebyte(SB) // 调用函数， 此行后面的几行代码是将返回值赋值给变量bs

// 现象二给runtime.stringtoslicebyte的传参
0x002f 00047 (test.go:6)    LEAQ    go.string."abc"(SB), AX // 将字符串"abc"放入寄存器AX
0x0036 00054 (test.go:6)    MOVQ    AX, "".a+120(SP) // 将AX中的内容存入变量a中
0x003b 00059 (test.go:6)    MOVQ    $3, "".a+128(SP) // 将字符串长度3存入变量a中
0x0047 00071 (test.go:7)    PCDATA  $0, $2
0x0047 00071 (test.go:7)    LEAQ    ""..autotmp_5+64(SP), CX // 将内部变量autotmp_5放入寄存器CX
0x004c 00076 (test.go:7)    PCDATA  $0, $1
0x004c 00076 (test.go:7)    MOVQ    CX, (SP) // 将CX中的内容传递给runtime.stringtoslicebyte(SB)的第一个参数
0x0050 00080 (test.go:7)    PCDATA  $0, $0
0x0050 00080 (test.go:7)    MOVQ    AX, 8(SP) // 将AX中的内容传递给runtime.stringtoslicebyte(SB)的第二个参数
0x0055 00085 (test.go:7)    MOVQ    $3, 16(SP) // 将字符串长度传递给runtime.stringtoslicebyte(SB)的第二个参数
0x005e 00094 (test.go:7)    CALL    runtime.stringtoslicebyte(SB)

通过上面汇编代码的分析可以知道，现象一和现象二的区别就是传递给runtime.stringtoslicebyte的第一个参数不同。 通过对runtime包中stringtoslicebyte函数分析，第一个参数是否有值和字符串长度会影响代码执行的分支，从而生成不同的切片， 因此容量不一样也是常理之中， 下面我们看源码

func stringtoslicebyte(buf *tmpBuf, s string) []byte {
    var b []byte
    if buf != nil && len(s) <= len(buf) {
        *buf = tmpBuf{}
        b = buf[:len(s)]
    } else {
        b = rawbyteslice(len(s))
    }
    copy(b, s)
    return b
}

然而， stringtoslicebyte的第一个参数什么情况下才会有值，什么情况下为nil, 我们仍然不清楚。那怎么办呢， 只好祭出全局搜索大法：

# 在go源码根目录执行下面的命令
grep stringtoslicebyte -r . | grep -v "//"

最终在go的编译器源码cmd/compile/internal/gc/walk.go发现了如下代码块

a5cabe30bfbf7f49f1a4f68f26ce0995.png

我们查看mkcall 函数签名可以知道, 从第四个参数开始的所有变量都会作为参数传递给第一个参数对应的函数， 最后生成一个*Node的变量。其中Node结构体解释如下:

// A Node is a single node in the syntax tree.
// Actually the syntax tree is a syntax DAG, because there is only one
// node with Op=ONAME for a given instance of a variable x.
// The same is true for Op=OTYPE and Op=OLITERAL. See Node.mayBeShared.

综合上述信息我们得出的结论是，编译器会对stringtoslicebyte的函数调用生成一个AST(抽象语法树)对应的节点。因此我们也知道传递给stringtoslicebyte函数的第一个变量也就对应于上图中的变量a.

其中a的初始值为nodnil()的返回值，即默认为nil. 但是n.Esc == EscNone时，a会变成一个数组。我们看一下EscNone的解释.

// 此代码位于cmd/compile/internal/gc/esc.go中
const (
    // ...
    EscNone           // Does not escape to heap, result, or parameters.
    ...
)

由上可知, EscNone用来判断变量是否逃逸,到这儿了我们就很好办了，接下来我们对现象一和现象二的代码进行逃逸分析.

# 执行变量逃逸分析命令: go run -gcflags '-m -l' test.go
# 现象一逃逸分析如下：
./test.go:7:14: ([]byte)(a) escapes to heap
./test.go:8:13: main ... argument does not escape
./test.go:8:13: bs escapes to heap
./test.go:8:21: len(bs) escapes to heap
./test.go:8:30: cap(bs) escapes to heap
[97 98 99] 3 8
# 现象二逃逸分析如下：
./test.go:7:14: main ([]byte)(a) does not escape
./test.go:8:13: main ... argument does not escape
./test.go:8:17: len(bs) escapes to heap
./test.go:8:26: cap(bs) escapes to heap
3 32

根据上面的信息我们知道在现象一中，bs变量发生了逃逸，现象二中变量未发生逃逸，也就是说stringtoslicebyte函数的第一个参数在变量未发生逃逸时其值不为nil,变量发生逃逸时其值为nil。到这里我们已经搞明白stringtoslicebyte的第一个参数了， 那我们继续分析stringtoslicebyte的内部逻辑

我们在runtime/string.go中看到stringtoslicebyte第一个参数的类型定义如下：

const tmpStringBufSize = 32

type tmpBuf [tmpStringBufSize]byte

综上: 现象二中bs变量未发生变量逃逸, stringtoslicebyte第一个参数不为空且是一个长度为32的byte数组, 因此在现象二中生成了一个容量为32的切片

根据对stringtoslicebyte的源码分析， 我们知道现象一调用了rawbyteslice函数

func rawbyteslice(size int) (b []byte) {
    cap := roundupsize(uintptr(size))
    p := mallocgc(cap, nil, false)
    if cap != uintptr(size) {
        memclrNoHeapPointers(add(p, uintptr(size)), cap-uintptr(size))
    }

    *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
    return
}

由上面的代码知道， 切片的容量通过runtime/msize.go中的roundupsize函数计算得出, 其中_MaxSmallSize和class_to_size均定义在runtime/sizeclasses.go

func roundupsize(size uintptr) uintptr {
    if size < _MaxSmallSize {
        if size <= smallSizeMax-8 {
            return uintptr(class_to_size[size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]])
        } else {
            return uintptr(class_to_size[size_to_class128[(size-smallSizeMax+largeSizeDiv-1)/largeSizeDiv]])
        }
    }
    if size+_PageSize < size {
        return size
    }
    return round(size, _PageSize)
}

由于字符串abc的长度小于_MaxSmallSize(32768)，故切片的长度只能取数组class_to_size中的值， 即0, 8, 16, 32, 48, 64, 80, 96, 112, 128....s

至此, 现象一中切片容量为什么为8也真相大白了。相信到这里很多人已经明白现象四和现象五是怎么回事儿了, 其逻辑分别与现象一和现象二是一致的， 有兴趣的， 可以在自己的电脑上面试一试。

字符串直接转切片

那你说了这么多， 现象三还是不能解释啊。请各位看官莫急， 接下来我们继续分析。

相信各位细心的小伙伴应该早就发现了我们在上面的cmd/compile/internal/gc/walk.go源码图中折叠了部分代码， 现在我们就将这块神秘的代码赤裸裸的展示出来

24950e5fa84cd8aa03482efd309066ee.png

我们分析这块代码发现,go编译器在将字符串转字节切片生成AST时，总共分为三步。

  1. 先判断该变量是否是常量字符串,如果是常量字符串,则直接通过types.NewArray创建一个和字符串等长的数组
  2. 常量字符串生成的切片变量也要进行逃逸分析，并判断其大小是否大于函数栈允许分配给变量的最大长度， 从而判断节点是分配在栈上还是在堆上
  3. 最后，如果字符串长度是大于0， 将字符串内容复制到字节切片中， 然后返回。因此现象三中的切片容量是3也就完全清楚了

结论

字符串转字节切片步骤如下

  1. 判断是否是常量， 如果是常量则转换为等容量等长的字节切片
  2. 如果是变量， 先判断生成的切片是否发生变量逃逸
  • 如果逃逸或者字符串长度>32， 则根据字符串长度可以计算出不同的容量
  • 如果未逃逸且字符串长度<=32, 则字符切片容量为32

扩展

常见逃逸情况

1. 函数返回局部指针

2. 栈空间不足逃逸

3. 动态类型逃逸, 很多函数参数为interface类型，比如fmt.Println(a ...interface{})，编译期间很难确定其参数的具体类型, 也会发生逃逸

4. 闭包引用对象逃逸

注: 写本文时， 笔者所用go版本为: go1.13.4

参考

https://golang.org/src/cmd/compile/README.md

https://my.oschina.net/renhc/blog/2222104

生命不息， 探索不止， 后续将持续更新有关于go的技术探索
原创不易， 卑微求关注收藏二连
weixin_39965514
关注
android app 十六进制字符串 String byte数组互转
安卓兼职framework和app工程师的博客
07-13 2271
在app的开发中，对于数据传输的相关功能中 byte数组和字符串互转的功能也是常见功能 byte数组 转十六进制字符串 十六进制字符串转换成字符串 的相关功能 2.2 java版实现功能的相关代码 3.总结 对于相关方法的说明，在代码中做了注释说明，按照说明理解相关代码就可以了......
Android byte[] 和 String互相转换
12-15
这个工程是简单将String和byte[]互相转换的Demo,有需要的可以下载
android开发中byte[]转换成String
12-10 711
想将byte[]转换成String的话，用byte[].toString()是不行的，貌似是编码的问题。用new String(byte[])就能正确转换了。 就是说： String s="abc"; byte[] b=s.getByte(); String s1=b.toString(); s1的输出结果就不是"abc"了。 如果这样： String s="abc"; byte[...
android byte转string_Android网络编程-Socket
weixin_39965075的博客
11-22 164
Socket在Android网络编程中，有着非常重要的作用。Socket基本概念即套接字，是应用层 与 TCP/IP 协议族通信的中间软件抽象层，表现为一个封装了 TCP / IP协议族 的编程接口(API)。从设计模式的角度看来，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议...
c++ string转double_bytes、string、编码、python
weixin_39534149的博客
11-21 434
最近经常遇到这个东西，记录一下。主要平台python3bytes是字节流，是二进制的数据，每一“位”占八个bit，也就是一个byte。这也是bytes这个名字的来源。这些byte也许可以直接显示，也许不行。对计算机来说，bytes是唯一真实存在于内存中的的东西。计算机所做的一切，就是为了解释这些二进制。他们也许是可执行程序，也许是图片，也许是音乐，也许是中文字符。string是一个对象，是你能看见...
Android byte 数组转 String
hegan2010的博客
07-04 4493
不知道什么原因，Android 的 String.java 的好多方法不能使用，抛出这样的异常： throw new UnsupportedOperationException("Use StringFactory instead."); 但是呢，StringFactory.java 这个类却又是 @hide，无法直接调用，无奈拷贝出其中的方法，拎出来使用： import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.ch
android byte字节数组转换十六进制字符串
01-09
在Android开发中，有时我们需要将字节数组（byte array）转换为十六进制字符串，以便于数据存储、传输或调试。这是因为字节数组是二进制数据，而十六进制字符串则是一种人类可读的表示方式。下面我们将详细讨论如何...
android把byte转换字符串,关于java：在android中将byte []转换为Hex字符串
weixin_42356340的博客
05-25 1359
本问题已经有最佳答案，请猛点这里访问。我正在尝试将字节[]转换为十六进制字符串，在Android中将相同的十六进制字符串转换为字节[]，数据不匹配。前任：接收字节[]数据：[B@B39C86A转换的十六进制字符串：8be897cc3c4d9e5d6a6bbd106d8e8d487691b56当我解码十六进制字符串时，我得到了[b@ea6d15b，但它应该是[b@b39c86a我正在使用下面的代码进...
python字符串转byte数组_在Python中将字符串转换为ctypes.c_ubyte数组的有效方法
weixin_39725365的博客
12-17 4281
我有一个20字节的字符串,我想将其转换为ctypes.c_ubyte数组以进行位字段操作.import ctypesstr_bytes = '01234567890123456789'byte_arr = bytearray(str_bytes)raw_bytes = (ctypes.c_ubyte*20)(*(byte_arr))有没有办法避免为了演员而从str到bytearray的深拷贝？或者...
android byte[] to String
yangtan_tanbaobao的博客
01-14 764
做一个蓝牙的项目，现实的数据总是乱码，以下亲测有用： //蓝牙部分 public void broadcastUpdate(final String action, final BluetoothGattCharacteristic characteristic) { final Intent intent = new Intent(action); final byte[] da...
Java中byte[]转String问题
kangming07的专栏
04-17 1263
最近的项目中要使用到把byte[]类型转换成String字符串然后通过网络发送，但发现发现出去的字符串和获取的字符串虽然是一样的，但当用String的getBytes()的方法得到的byte[]跟原来的byte[]是不一样的。 看如下代码： bytebytes[] = new byte[] { 50, 0, -1, 28, -24 }; String string = new Strin
Android中将Byte数据转成String
Blue_Tong的博客
08-25 3812
【代码】Android中将Byte数据转成String。
android byte[] 转string 好多问号_Android高级架构进阶之数据传输与序列化
weixin_36123285的博客
12-05 317
更多Android高级架构进阶视频学习请点击：https://space.bilibili.com/474380680本篇文章将从以下几个内容来阐述数据传输与序列化:[Serializable原理][Parcelable的原理和使用方法][json]一、Serializable原理1.概念序列化：把Java对象转换为字节序列的过程。反序列化：把字节序列恢复为Java对象的过程。2.用途 对象的序列...
Android byte[] 转 string
weixin_34417814的博客
11-28 184
2019独角兽企业重金招聘Python工程师标准>>> ...
android byte转string_一篇文章让你清楚明白string类常用方法
weixin_39635084的博客
11-26 1494
String在所有的项目开发中都一定要使用到，那么在String类里面提供了一系列的功能操作方法，本次学习其中大部分的操作方法，而对于有一些操作，需要等待全部的知识掌握之后才可以进行后续的学习。 对于系统类的方法，一定要去查询文档，一些不常用的方法允许不知道，但是一定要会查。而对于String类的一些方法，由于使用的情况比较多，为了方便开发必须背。对于每一个API文档的内容而言，都由...
android byte[] 转string 好多问号_#WIPI# Android使用HID设备
weixin_36019543的博客
12-12 140
哈罗大家好。生活总是这样计划赶不上变化，今天为大家分享一下新加的小功能--使用Android设备连接HID设备。 安卓内部已经内置了丰富的驱动，所以一般的设备我们只需要简单是设置就可灵活使用。首先对清单文件做简单修改<manifest xmlns:android="http://schemas.android.com/apk/res/android" packa...
android byte 转string 乱码,byte[]转String，编码与乱码问题
weixin_39519798的博客
05-28 3695
String str = new String(byte[]);转化之后可能会出现乱码的问题。编码规范不一样。举个栗子，比如GB2312规范的中文“当”字，就是用0xB5,0xB1这两个八位的数字来表示的。在英文系统上，没有GB2312编码表，给他一个0xB5,0xB1，他就傻傻的当作ASCII来处理。放到Java里，他又会按照自己的UNICODE规范来处理，所以规范不一样，就会出现奇怪的结果，也...
字符串性能优化不容小觑
qq_38862257的博客
11-02 247
String对象是我们日常工作中使用最频繁的对象，它的性能问题也是我们最容易忽略的。String对象作为Java语言中最重要的数据类型，是内存中占据空间最大的对象，高效地使用字符串，可以提升系统的整体性能。 今天这篇文章我们从String对象的实现、特性以及实际使用中的优化三方面，来深入了解String对象。 String对象是如何实现的 在Java更新的版本变化中，对String对象已经做了大量的优化，来节约内存空间，提升String对象在系统中的性能。来看看在Java版本迭代中String的优化过程;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值