一个问题让你搞清Golang数组和切片的变量复制

最新推荐文章于 2025-03-02 16:13:03 发布
最新推荐文章于 2025-03-02 16:13:03 发布
阅读量682 收藏 14
点赞数 7
文章标签： golang 爬虫 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sc35262/article/details/144428304
版权

切片slice和数组array是golang中常见且重要的数据类型。一言以蔽之，从使用角度看来，数组是有固定长度的特殊切片；而切片是一个可以自动扩容的不定长数组。

但是两种数据类型在底层实现上又有着本质的区别。我们知道在golang中变量分为值类型变量和引用类型变量。其中 string、int、float、bool和 array等基础类型属于值类型变量，而 slice、map、chan 等则属于引用类变量。

在对象拷贝时，golang默认采用值拷贝的策略，即深度拷贝策略；但是对slice、map、chan 等类型，由于其本身属于引用类型，变量本身存储的就是指针数据，所以实际为浅拷贝。因此数组和分片在拷贝后的修改对于原来变量的影响会有所区别。下面我们用三个例子来说明这种区别

1、数组拷贝

 

golang
 

代码解读
 

复制代码
 

func main() { a := [3]int{1, 2, 3} b := a c := &a b[0] = 10 c[0] = 5 fmt.Printf("a = %v,ptr = %p\n", a, &a) fmt.Printf("b = %v,ptr = %p\n", b, &b) fmt.Printf("c = %v,ptr = %p\n", c, c) } 
 

测试输出为：
 

 

text
 

代码解读
 

复制代码
 

a = [5 2 3],ptr = 0x1400011a018 b = [10 2 3],ptr = 0x1400011a030 c = &[5 2 3],ptr = 0x1400011a018 
 

通过上面的例子，我们可以发现, 数组对象拷贝后会生成两个不相关的数组变量，分别指向不同的地址空间，修改某一个变量，另一个变量不会受到影响，但是当我们通过变量c来拷贝a变量的指针时，通过修改变量c，是可以影响变量a的，因为两个对象指向同一块地址空间。
 

2、切片拷贝1
 

 

golang
 

代码解读
 

复制代码
 

func main() { a := []int{1, 2, 3} b := a[:2] fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 10 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 4) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 5) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 20 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) } 
 

测试输出为：
 

 

text
 

代码解读
 

复制代码
 

a = [1 2 3],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [1 2],cap = 3,len= 2, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0d8 a = [10 2 3],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [10 2],cap = 3,len= 2, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0d8 a = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0d8 a = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [10 2 4 5],cap = 6,len= 4, 底层数组地址 = 0x14000016210, 变量地址 = 0x1400000c0d8 a = [10 2 4],cap = 3,len= 3, 底层数组地址 = 0x1400001a120, 变量地址 = 0x1400000c0c0 b = [20 2 4 5],cap = 6,len= 4, 底层数组地址 = 0x14000016210, 变量地址 = 0x1400000c0d8 
 

通过上面的例子可以发现，切片对象拷贝后，会生成两个变量，变量地址指向不同的地址空间，从a和b 分别具有不同的 len 值，也可以确认a和b对象本身是两个完全独立的对象。但是两个变量指向的底层数组地址一致，说明切片对象内容的拷贝是浅拷贝。因此当我们操作b[0]的数值时，a 切片的值也会受到影响。
 

当我们第一次针对b执行append(b, 4)操作时，由于其b变量的cap空间足够，因此不会重现生成新的底层数组对象，此时与a仍然共用同一个底层数据，只不过会将4覆盖原来b[2]的值，因此a[2]的值也会受到影响。
 

当我们第二次针对b执行append(b, 5)操作时，由于其b变量的cap空间已经被全部占用，因此触发切片扩容，需要重现申请底层数组空间，此时我们可以看到，b变量本身的地址不变，但是其指向的底层数组地址发生了变化。因此此时我们在修改b[0]时，a[0]的值不会受到影响。
 

切片扩容的原理及源码实现可以参考上一篇文章golang数组和切片的区别
 

3、切片拷贝2
 

 

golang
 

代码解读
 

复制代码
 

func main() { a := []int{1, 2, 3} b := a[1:] fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 10 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 4) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 20 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) } 
 

测试输出为：
 

 

text
 

代码解读
 

复制代码
 

a = [1 2 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [2 3],cap = 2,len= 2, 底层数组地址 = 0x1400011a020, 变量地址 = 0x1400012c0c0 a = [1 10 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [10 3],cap = 2,len= 2, 底层数组地址 = 0x1400011a020, 变量地址 = 0x1400012c0c0 a = [1 10 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [10 3 4],cap = 4,len= 3, 底层数组地址 = 0x1400014e040, 变量地址 = 0x1400012c0c0 a = [1 10 3],cap = 3,len= 3, 底层数组地址 = 0x1400011a018, 变量地址 = 0x1400012c0a8 b = [20 3 4],cap = 4,len= 3, 底层数组地址 = 0x1400014e040, 变量地址 = 0x1400012c0c0 
 

通过上面的例子可以发现，切片对象拷贝后，由于b取的是a数组的后两个元素，而数组的空间是连续的，因此b切片的cap变为2，同时b的底层数据地址刚好指向a切片底层数组的第二个元素地址。由于我们的数组类型为int类型，系统为64位，每个元素占用8字节，由于数组地址连续，b的底层数组地址 正好等于 切片a 底层数组地址 0x1400011a018 + 8，即b切片第一个元素地址正对切片底层数组的第二个元素。此时我们修改 b[0] = 10 值，则a[1]也会同步被修改为10。
 

当我们针对b执行append(b, 4)操作时，由于其b变量的cap空间已经被全部占用，因此触发切片扩容，需要重现申请底层数组空间，此时我们可以看到，b切片指向的底层数组地址发生了变化。因此此时我们再修改b[0]时，a[1]的值不会受到影响。
 

4、总结
 

相信通过上面三个测试用例，可以很清楚的说明golang中数组和切片变量的对象复制区别。我们可以总结为以下几个要点：
 

  • 数组变量为值复制，复制后变量之间独立。除非指定为变量指针传递。
  • 切片变量为指针复制，复制后变量操作是否会影响原变量，取决于该才操作是否会触发切片的扩容。
 

请思考以下测试用例的输出结果：
 

 

golang
 

代码解读
 

复制代码
 

func main() { a := []int{1, 2, 3, 4} b := a[1:3] fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 10 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 5) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 20 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b = append(b, 6) fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) b[0] = 30 fmt.Printf("a = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", a, cap(a), len(a), a, &a) fmt.Printf("b = %+v,cap = %d,len= %d, 底层数组地址 = %p, 变量地址 = %p\n", b, cap(b), len(b), b, &b) }

                

        

    

  



    

      

        

            

              
                
                  Java八股文
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
面试摘要【持续更新】

				
			

			

				

					SUNJIFENG666的博客
				

				

					05-23
					
					674
					
				

			

		

		

			
				
1、中熔断和限流怎么做的，熔断、降级、限流【方法：令牌桶、漏桶、滑动窗口】1）、限流有哪几种方式？我扯了阿里sentinel的令牌桶、漏斗、冷启动、自适应限流（bbr、cpu load），为什么bbr公式能做到自适应限流？当时没想明白这个问题问什么，然后面试官说了可以根据结果来做调整。参考资料：bbr服务容错：单机器多线程限流2、设计模式3、序列化工具参考资料 ：ProtoBuf ：4、百万微服务如何定位出现的微服务5、分布式 ID九种实现。

			
		

	



                

            
              



	

		

			

				
					
Golang基础-切片

				
			

			

				

					每天进步一点点！！！
				

				

					10-14
					
					525
					
				

			

		

		

			
				
切片
文章目录切片1.切片的引入2.内存分析3.切片的定义4.切片的遍历5.切片的注意事项
1.切片的引入
【1】切片(slice)是golang中一种特有的数据类型
【2】数组有特定的用处，但是却有一些呆板(数组长度固定不可变)，所以在 Go 语言的代码里并不是特别常见。相对的切片却是随处可见的，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。
【3】切片(slice)是对数组一个连续片段的引用，所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终止索引标识的一

			
		

	



              


  
              

                


	

		

			

				
					
Golang：数组与切片的复制

				
			

			

				

					ミ安之偌素
				

				

					06-09
					
					2795
					
				

			

		

		

			
				
在Golang中，数组是值类型而切片是引用类型。因此值的复制与切片的复制并不相同。
数组的复制
对于值类型的数组来说，变量指向的并不是第一个元素的指针，而是整个数组。以下情况会发生数组的复制：

将数组变量赋值给另一个数组变量
将数组变量作为参数传递给方法
举个栗子：

package main

import "fmt"

func main() {
    sample1 := [2]string{"a", "b"}
    fmt.Printf("Sample1 Before: %v\n", samp

			
		

	





	

		

			

				
					
golang切片拷贝

				
			

			

				

					qingyu3044的博客
				

				

					07-05
					
					388
					
				

			

		

		

			
				
去若是浅拷贝，原始的切片变化后所有的切片都会变化，无论切片是否在一个函数，还是一个goroutine中，都会发生变化。出现非常奇怪的问题切片内容经常莫名奇妙的改变，最后发现是切片赋值的问题。如下代码问题困扰了好久，才发现是切片赋值的问题。golang切片有浅拷贝和深拷贝的区别。

			
		

	



		

			
		



	

		

			

				
					
golang：切片拷贝

				
			

			

				

					OceanStar的博客
				

				

					08-22
					
					2286
					
				

			

		

		

			
				
内置函数copy()可以将一个数组切片复制到另一个数组切片中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。
copy( destSlice, srcSlice []T) int

其中 srcSlice 为数据来源切片，destSlice 为复制的目标（也就是将 srcSlice 复制到 destSlice），目标切片必须分配过空间且足够承载复制的元素个数，并且来源和目标的类型必须一致，copy() 函数的返回值表示实际发生复制的元素个数。
下面的代码展示了使用 cop

			
		

	





	

		

			

				
					
简单笔记：记一次 golang 的切片复制

				
			

			

				

					weixin_41346635的博客
				

				

					04-21
					
					1069
					
				

			

		

		

			
				
常规情况下 golang 的一维数组复制，可以这样写：


func copy(src []int) []int {
	copy0 := make([]int, len(src))
	copy(copy0, src)
    return copy0
}

这样写，会新开辟一块内存空间，对切片副本的任何修改操作，不会影响原切片。

如果需求是二维数组，出于惯性思维，可能会这样写：


func copy0(src [][]int) [][]int {
	copy0 := make_slice2(len(sr

			
		

	





	

		

			

				
					
Golang笔记

				
			

			

				

					怨行客
				

				

					10-18
					
					638
					
				

			

		

		

			
				
协程是用户态轻量级线程协程是线程调度的基本单位通常在函数前加上go关键字就能实现并发。一个Goroutine会以一个很小的栈启动2KB或4KB，当遇到栈空间不足时，栈会自动伸缩， 因此可以轻易实现成千上万个goroutine同时启动。

			
		

	





	

		

			

				
					
golang深度学习-内存管理

					
最新发布

				
			

			

				

					G970620的博客
				

				

					03-02
					
					958
					
				

			

		

		

			
				
TCMalloc（Thread-Caching Malloc）是由Google开发的一种内存分配器，用于替代标准C库中的malloc和free函数。它主要用于提高多线程环境下程序的内存分配和释放性能，特别是在高并发情况下。使用TCMalloc能够有效地提升程序的性能，特别是在多线程并发环境下，减少锁竞争和内存碎片对性能造成的影响。

			
		

	





	

		

			

				
					
【2022版】Golang面试题目全网超全超详细的口语化解答总结

				
			

			

				

					一年之内毫无半点成绩，想起来做人真是没趣。
				

				

					06-10
					
					9560
					
				

			

		

		

			
				
GO语言面试题目总结，站在巨人的肩膀上吧，也有自己的分析。有相关的题目。

			
		

	





	

		

			

				
					
Go语言学习笔记—golang函数

				
			

			

				

					qq_39280718的博客
				

				

					06-22
					
					433
					
				

			

		

		

			
				
golang 函数

			
		

	





	

		

			

				
					
golang切片和数组拷贝（浅拷贝和深拷贝）

				
			

			

				

					西京刀客
				

				

					10-22
					
					9205
					
				

			

		

		

			
				
我们提到的深拷贝和浅拷贝，则指的是引用类型的值处理方案。数组和切片属于哪种？
浅拷贝指的是，把变量里面存的内存地址拷贝了，所指向的真实值并没拷贝。

			
		

	





	

		

			

				
					
golang 复制对象

				
			

			

				

					whatday的专栏
				

				

					11-20
					
					2615
					
				

			

		

		

			
				
需求

　　实际运用种，传参是一对象指针，现在如何最简便地复制一对象？

实现

错误方法：&* 先拿到值再指针？


package main
 
import (
    "time"
    "log"
)
 
func main() {
 
    T1 := &TestS{1}
    T2 := &*T1
    T2.a = 5
    log.Print(T1)
    log.Print(T2)
}

输出


2017/06/15 20:14:27 &{.

			
		

	





	

		

			

				
					
【Golang】数组 && 切片

				
			

			

				

					Suk_god的博客
				

				

					10-02
					
					967
					
				

			

		

		

			
				
当 map 增长到容量上限的时候，如果再增加新的 key-value，map 的大小会自动加 1，所以出于性能的考虑，对于大的 map 或者会快速扩张的 map，即使只是大概知道容量，也最好先标明。Go语言的内置函数 copy() 可以将一个数组切片复制到另一个数组切片中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。N维数组本质上是一个一维数组，这个一维数组的每个元素是N-1维数组，以此类推，直到访问到最底一层，能够直接处理数组中的元素。

			
		

	





	

		

			

				
					
golang 对slice的深拷贝 copy

				
			

			

				

					weixin_33787529的博客
				

				

					03-28
					
					3548
					
				

			

		

		

			
				
测试 slice的地址 copy的时候 发现有问题：

package main

import "fmt"

func main() {
    nums:=[]int{1,2,3,4,5}
    fmt.Println("     len cap   address")
    fmt.Print("111---",len(nums),cap(nums))
    fmt...

			
		

	





	

		

			

				
					
go语言之切片复制与追加

				
			

			

				

					路漫漫其修远兮，吾将上下而求索
				

				

					05-06
					
					1252
					
				

			

		

		

			
				
示例代码：
package main

import (
	"fmt"
)

func main() {
	// copy示例
	// 创建一个新的更大的切片并把原分片的内容都拷贝过来
	sl_from := []int{1, 2, 3}
	sl_to := make([]int, 10)
	n := copy(sl_to, sl_from)
	fmt.Println("num:", n, "it...

			
		

	





	

		

			

				
					
Go语言切片【复制（copy 、append）、剪切、删除（append、copy、len）等操作

				
			

			

				

					wgchen
				

				

					08-03
					
					1114
					
				

			

		

		

			
				
然而，如果切片 a 的长度为偶数，例如长度为 6，那么中间的元素索引为 2 和 3。然后，使用循环遍历排序后的切片，将不重复的元素移到切片的前部。使用两个 append 函数完成，即先将索引i之后的元素追加到一个长度为 j 的切片后，再将这个切片中的所有元素追加到切片 a 的索引i之后。这个示例展示了如何在切片中移动元素并维护元素的相对位置，以及如何在需要时将新的元素添加到切片的前面。最后，我们通过切片操作。的元素，无需保留切片元素原有的顺序，那么还可以使用下面这种简单的方式进行删除。

			
		

	





	

		

			

				
					
golang复制切片的方法（避免操作同一底层数组）

				
			

			

				

					weixin_43970884的博客
				

				

					07-29
					
					848
					
				

			

		

		

			
				
切片拷贝

			
		

	





	

		

			

				
					
GoLang复制/拷贝一个切片

				
			

			

				

					zhang197093的博客
				

				

					12-19
					
					1152
					
				

			

		

		

			
				
使用内建方法copy

func CopySlice(src []int) []int {
	if src == nil {
		return nil
	}
	dup := make([]int, len(src))
	copy(dup, src)
	return dup
}


使用append方法

func CopySlice(src []int) []int {
	return append([]int(nil), src...)
}

主要说的是使用append方法，语法简洁，golang源码中.

			
		

	





	

		

			

				
					
golang的数组和切片

				
			

			

				

					09-13
				

			

		

		

			
				
Golang的数组和切片是两种不同的数据类型，用于存储相同数据类型的容器。数组的长度是固定的，而切片的长度是可变的。在日常应用中，切片的使用更为普遍。

数组在声明时需要指定长度，并且在初始化时必须提供相同长度的元素。例如，`a := int{1, 2, 3}`就是一个长度为3的整数数组。数组的长度一旦确定后就不能更改。

切片是基于数组的引用类型。它不需要指定固定的长度，并且可以根据需要动态扩展或缩小。切片包装着底层数组，通过指定起始索引和结束索引来指定子集。例如，`b := a[:]`就是一个切片，它包含了数组a的所有元素。

数组适用于需要固定长度的场景，而切片适用于长度可变的情况。在实际应用中，切片更常用，因为它提供了更大的灵活性和便利性。

总结：
- 数组是长度固定的容器，切片是长度可变的容器；
- 数组在声明时需要指定长度，切片则不需要；
- 数组的长度一旦确定后就不能更改，而切片可以根据需要动态扩展或缩小；
- 切片是基于数组的引用类型，可以通过指定起始索引和结束索引来指定子集。

参考资料：
 Golang中的「数组」和「切片」都是存储同一数据类型的容器，只不过Golang中的数组长度是固定的，而切片的长度是可变化的。
 切片是引用类型，切片包装的数组称为该切片的底层数组。我们来看一段代码：//a是一个数组，注意数组是一个固定长度的，初始化时候必须要指定长度，不指定长度的话就是切片了 a := int{1, 2, 3} //b是数组，是a...。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值