OC内存管理

最新推荐文章于 2022-02-13 13:38:58 发布
最新推荐文章于 2022-02-13 13:38:58 发布
阅读量606 收藏
点赞数
分类专栏： ios基础 文章标签： Object-c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012897297/article/details/41910029
版权


一、内存管理概述

1. 什么是内存管理
 移动设备的内存极其有限，每个app所能占用的内存是有限制的。当app所占用的内存较多时，系统会发出内存警告，这时得回收一些不需要再使用的内存空间。比如回收一些不需要使用的对象、变量等
 管理范围：任何继承了NSObject的对象，对其他基本数据类型（int、char、float、double、struct、enum等）无效
2. 对象的基本结构

   每个OC对象都有自己的引用计数器，是一个整数，表示“对象被引用的次数”，即有多少人正在使用这个OC对象
 每个OC对象内部专门有4个字节的存储空间来存储引用计数器
3. 引用计数器的作用
 当使用alloc、new或者copy创建一个新对象时，新对象的引用计数器默认就是1
 当一个对象的引用计数器值为0时，对象占用的内存就会被系统回收。换句话说，如果对象的计数器不为0，那么在整个程序运行过程，它占用的内存就不可能被回收，除非整个程序已经退出
4. 引用计数器的操作
 给对象发送一条retain消息,可以使引用计数器值+1（retain方法返回对象本身）。
 给对象发送一条release消息,可以使引用计数器值-1。
 可以给对象发送retainCount消息获得当前的引用计数器值。
5. 对象的销毁
 当一个对象的引用计数器值为0时，那么它将被销毁，其占用的内存被系统回收。
 当一个对象被销毁时，系统会自动向对象发送一条dealloc消息。
 一般会重写dealloc方法，在这里释放相关资源，dealloc就像对象的遗言。
 一旦重写了dealloc方法，就必须调用[super dealloc]，并且放在最后面调用。
 不要直接调用dealloc方法，这是系统自动调用的。
 一旦对象被回收了，它占用的内存就不再可用，坚持使用会导致程序崩溃（野指针错误）。

#import <Foundation/Foundation.h>

//声明Person
@interface Person : NSObject
@end

//Person实现
@implementation Person

//重写dealloc方法，当对象被销毁时会自动被调用
- (void)dealloc
{
    NSLog(@"对象被回收");
    [super dealloc]; //父类的dealloc方法必须一定要调用，并且必须写在最后一行
}
@end

int main()
{
    Person *p=[[Person alloc]init]; //调用了alloc方法，对象计数器变为1
    
    int count=(int)[p retainCount]; // 当前对象的计数器的值
    NSLog(@"count=%d",count);
    
    [p retain]; //对象计数器+1，此时计数器为2.该方法返回值是对象本身
    [p release]; //对象计数器-1，此时计数器为1
    
    [p release]; // 对象计数器为0，对象被回收
    
    // [p release];
    /*
     对象计数器此时已经为0，代表刚才那个对内存中的对象已经被回收了，这个内存现在叫做僵尸对象。但是变量p还是会指向那块内存空间。此时的指针叫做野指针。所以，这句代码就是给野指针发送release消息。会报错：EXC_BAD_ACCESS:访问了一块坏内存（已经被回收、不可用的内存），也叫野指针错误。
     */
    
    p=nil; //清空指针
    [p release]; // 这样就不会报错了，因为OC和C中没有空指针异常错误，给空指针发送release消息是不会报错的
    
    
    return 0;
}
/*
 总结：
 1。僵尸对象：所占用内存已经被回收的对象，僵尸对象不能再使用
 2.野指针：指向僵尸对象（不可用内存）的指针，给野指针发送消息会报错-EXC_BAD_ACCESS
 3.空指针：没有指向任何东西的指针，（存储的东西是nil、NULL、0），给空指针发送消息不报错。
 
 */
内存管理原则：
只要你想用这个对象，就让对象的计数器+1
当你不再使用这个对象时，就让对象的计数器-1

二、多对象内存管理 

#import <Foundation/Foundation.h>
//声明dog
@interface Dog : NSObject
{
    int _age;
}
- (void)setAge:(int)age;
@end

@implementation Dog
//重写dealloc方法
- (void)dealloc
{
    NSLog(@"age=%d的Dog被回收",_age);
    [super dealloc];
}

- (void)setAge:(int)age
{
    _age=age;
}
@end

//声明Student类
@interface Student : NSObject
{
    int _no;
    Dog *_dog;
}


//各个成员变量set和get方法的声明
- (void)setNo:(int)no;
- (int)no;


- (void)setDog:(Dog *)dog;
- (Dog *)dog;
@end

@implementation Student
//各成员变量set和get的实现
- (void)setNo:(int)no
{
    _no=no; //基本数据类型不存在内存泄露，所以正常赋值
}
- (int)no
{
    return _no;
}


- (void)setDog:(Dog *)dog
{
    if(dog!=_dog) //避免当前对象计数器为1，但依然赋值同一个对象的情况
    {
        [_dog release]; //不用这个对象，就让计数器-1
        _dog=[dog retain]; //用这个对象，就让计数器+1
    }
}
- (Dog *)dog
{
    return _dog;
}


- (void)dealloc
{
    [_dog release]; //临死前，把拥有的对象-1
    NSLog(@"Student 被回收");
    [super dealloc];
}
@end
int main()
{
    Student *s=[[Student alloc]init]; //s=1
    
    Dog *d1=[[Dog alloc]init]; //d1=1
    s.dog=d1; //d1=2
    d1.age=2;
    
    //s.dog=[[Dog alloc]init]; 这是有内存泄露的，这个Dog对象未被回收
    
    Dog *d2=[[Dog alloc]init];
    d2.age=7;
    s.dog=d2; //d1-1=1,d2=2
    
   
    [d2 release]; //d2=1
    [d1 release]; //d1=0
    [s release]; //s=0,d2=0
    return 0;
}

/*
 总结：内存管理的代码规范
 1.只要调用了alloc，必须有relea（autorelease）
   如果对象不是通过alloc创建的，就不要release。字符串对象不需要release。
 2.set方法的代码规范
   1>基本数据类型：直接赋值
     - (void)setAge:(int)age
    {
        _age=age;
    }
   2>OC对象
     - (void)setCar:(Car *)car
    {
        //先判断是不是新传进来对象
        if(car!=_car)
        {
            //对旧的对象做一次release
            [_car release];
            //对新的对象做一次retain
            [car retain];
        }
    }
 3.dealloc方法的代码规范
   1>一定要有[super dealloc],而且放到最后
   2>对self所拥有的对象做一次release
    - (void)dealloc
    {
        [_car release];
        [super dealloc];
    }
 
 */

Xcode特性：

@property参数
1. 控制set方法的内存管理
 retain ： release旧值，retain新值（用于OC对象）
 assign ： 直接赋值，不做任何内存管理(默认，用于非OC对象类型)
 copy ： release旧值，copy新值（一般用于NSString *）

2. 控制需不需生成set方法
 readwrite ：同时生成set方法和get方法声明和实现（默认）
 readonly ：只会生成get方法声明和实现

3. 多线程管理
 atomic ：性能低（默认）
 nonatomic ：性能高，生成set时加锁

4. 控制set方法和get方法的名称,这不会影响到成员变量的名称。
 setter ： 设置set方法的名称，一定有个冒号:
 getter ： 设置get方法的名称
   一般不会用到，但是往往BOOL类型的get方法会用到，比如@property (getter=isRich) BOOL rich;

上述参数中，同类型的参数不能一起用，不同类型的参数可以一起用，用逗号隔开。

//上面代码中的Student类可以改为：

//声明Student类
@interface Student : NSObject

@property int no;
@property (retain)Dog *dog;
/*
 上面这句生成的set方法就相当于
 - (void)setDog:(Dog *)dog
 {
 if(dog!=_dog) //避免当前对象计数器为1，但依然赋值同一个对象的情况
 {
 [_dog release]; //不用这个对象，就让计数器-1
 _dog=[dog retain]; //用这个对象，就让计数器+1
 }
 }*/
@end

@implementation Student

- (void)dealloc
{
    [_dog release]; //临死前，把拥有的对象-1
    NSLog(@"Student 被回收");
    [super dealloc];
}
@end


注意：

dealloc方法还是要手动写的，且不要忘记将拥有的对象一一做一次release.
并且property参数中，凡是对象，都要加(nonatomic,retain),基本数据类型最好也加上（nonatomic,assign）


三、类循环引用

    A类引用B类，同时B类也引用A类，这就是循环引用。但是，若在各自的头文件中都#import对方的.h文件会报错，这种情况下，就将#import换成@class 类名。@class就是仅仅是告诉编译器，该变量是个类。

@class和#import的区别
    #import方式会包含被引用类的所有信息，包括被引用类的变量和方法；@class方式只是告诉编译器在A.h文件中 B *b 只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中信息。
    如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来 讲，使用@class方式就不会出现这种问题了。
    在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。


开发中引用一个类的规范：

1>在.h文件中用@class来声明类

2>在.m文件中，用#import来包含类的所有东西


两端循环引用的解决方案：

 一端用retain，一端用assign（这端的dealloc方法中，不要release这个变量） 

例子：

main.m文件：

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Card.h"

int main()
{
    Person *p=[[Person alloc]init];
    Card *c=[[Card alloc]init];
    
    p.card=c;
    c.person=p;
    
    [c release];
    [p release];
    return 0;
}
Person.h文件： 

#import <Foundation/Foundation.h>
@class Card;
//声明Person
@interface Person : NSObject
@property (nonatomic,assign)Card *card;
@end
Person.m文件： 

#import "Person.h"
#import "Car.h"
//Person实现
@implementation Person

//重写dealloc方法，当对象被销毁时会自动被调用
- (void)dealloc
{
    //_card是assign,仅仅是赋值，所以不用release
    NSLog(@"Person被回收");
    [super dealloc]; }
@end
Card.h文件： 

#import <Foundation/Foundation.h>
@class Person;
@interface Card : NSObject
@property (nonatomic,retain)Person *person;
@end

Card.m文件：

#import "Card.h"
#import "Person.h" //用到了Person 的对象方法release，所以将文件拷贝

@implementation Card
//重写dealloc方法
- (void)dealloc
{
    [_person release];//_person的property参数是retain，所以要release
    NSLog(@"Card被回收");
    [super dealloc];
}
@end

四、autorelease

1. autorelease
   给某个对象发送一条autorelease消息时，就会将这个对象加到一个自动释放池中。
   当自动释放池销毁时，会给池子里面的所有对象发送一条release消息。
   调用autorelease方法时并不会改变对象的计数器，并且会返回对象本身。
   autorelease实际上只是把对release的调用延迟了，对于每一次autorelease，系统只是把该对象放入了当前的autorelease pool中，当该pool被释放时，该pool中的所有对象会被调用Release。 

int main()
{
    @autoreleasepool { //代表创建了释放池
        // 将两个对象放到释放池中
        Person *p=[[[Person alloc]init]autorelease];
       
        Card *card=[[[Card alloc]init]autorelease];
    } //代表释放池销毁，p和card都会做一次release。
    return 0;
}
2.autorelease的好处

1>不用关心对象释放时间

2>不用再关心什么时候调用release

3.autorelease的使用注意

1>占用内存太大的对象不要随便使用autorelease

2>占用内存小的对象使用autorelease，没有太大影响

4.错误写法

1>alloc方法后调用了autorelease，又调用release

2>多次连续调用autorelease方法

在ios程序运行过程中，会创建无数个池子，这些池子都是以栈结构存在（先进先出）。当一个对象调用autorelease方法时，会将这个对象放到栈顶的释放池。

释放池可以嵌套定义无数个。
5. 自动释放池的创建
 ios 5.0后
   @autoreleasepool
   {
// ....
   }
 ios 5.0前
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   // .....
   [pool release]; // 或[pool drain];
在程序运行过程中，可以创建多个自动释放池，它们是以栈的形式存在内存中。OC对象只需要发送一条autorelease消息,就会把这个对象添加到最近的自动释放池中(栈顶的释放池)。

6.规律
1>系统自带的方法里没有包含alloc、new、copy，说明返回的对象都是autorelease的，所以不用管内存，比如NSString.

  2>开发中经常会提供一些类方法快速创建一个已经autorelease过的对象。创建对象时，不要直接用类名，一般用self.

<pre name="code" class="objc">#import <Foundation/Foundation.h>

//声明Person
@interface Person : NSObject

@property (nonatomic,assign)int age;
+ (id)person;

@end

#import <Foundation/Foundation.h>

//声明Person
@interface Person : NSObject

@property (nonatomic,assign)int age;
+ (id)person;

@end

//Person实现
@implementation Person

//将[[[Person alloc]init]autorelease]封装成一个类方法
+ (id)person
{
    //这种创建对象的方法最好用self，这样子类调用时返回的是子类对象
    return [[[self alloc]init]autorelease];
}
//重写dealloc方法，当对象被销毁时会自动被调用
- (void)dealloc
{
    NSLog(@"Person被回收");
    [super dealloc];
}

@end
int main()
{
    @autoreleasepool {
        Person *p=[Person person];
        p.age=10;
    }
    return 0;
}



 
五、ARC 
    ARC是编译器特性。（不是垃圾回收！！是编译时自动生成代码，编译器会自动在适当的地方插入适当的retain、release、autorelease语句） 

 

1.ARC的判断标准：只要没有强指针指向对象，就会释放对象。
 

2.强指针：__strong，默认情况下，所有指针都是强指针。
 

  弱指针：__weak，弱指针对象销毁后，弱指针也会随之消失。弱指针是不能创建对象的，
 

         比如：__weak Person *p=[[Person alloc]init];这立即销毁了
 

 

#import <Foundation/Foundation.h>

//声明Person
@interface Person : NSObject
@property (nonatomic,strong)Dog *dog; //代表dog是个强指针
@property (nonatomic,assign)int age;
@end

@implementation Person

//重写dealloc方法，ARC下，该方法不能调用父类dealloc
- (void)dealloc
{
    NSLog(@"Person被回收");
}
@end

// 声明Dog
@interface Dog : NSObject
@end

@implementation Dog

- (void)dealloc
{
    NSLog(@"Dog被回收");
}
@end

int main(int argc, const char * argv[])
{
    Person *p=[[Person alloc]init];
    __weak Person *p1=p;
    p=nil; //这句过后Person对象就被销毁了，因为指向这个对象的只有p1这个弱指针
    NSLog(@"%@",p1); //打印为空
    
    Person *p2=[[Person alloc]init];
    Dog *d=[[Dog alloc]init];
    p2.dog=d;
    p2=nil; //Person对象被回收，那么也就没有指向Dog对象的指针了，所以也被回收
    
    return 0;
}
 

 


 
 总结： 

*不能调用release、retain、autorelease、retainCount
 *可以重写dealloc，但是不能调用[super dealloc]
 *@property 参数：
 

 strong:成员变量是强指针（OC对象类型）
 

 weak:成员变量是弱指针（OC对象类型）
 

 assign:适用于非OC对象类型
 

*以前的retain改为strong
 *两端循环引用时，一端用strong、一端用wea
 
 


 
 

把一个非ARC的代码改成ARC代码，要用到Xcode的一个功能：
 

Eidt——>Refactor——>converto Objective-C ARC,然后一直下一步就行。
 


 
 

如何查看项目是ARC还是非ARC：
 

点击项目->Build Setting,搜索auto,然后查看Object-c Automatic Reference Counting 是yes还是no
 


 
 

在一个ARC的项目中，某些文件需要非ARC，那就需要改掉这些要非ARC文件的设置：点击项目->Build Phases->Compile Sources,双击需要非ARC的文件，弹出一个框，在框内输入  -fno-objc-arc 回车即可。
 


 
 

在一个非ARC的项目中，某些文件需要ARC，那就需要改掉这些要ARC文件的设置：点击项目->Build Phases->Compile Sources,双击需要ARC的文件，弹出一个框，在框内输入  -f-objc-arc 回车即可。
 
 
 
 


 

                

        

        

    

  


    

      

        

            

              
                
                  嗨123v
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
iOS —— 简述OC 的内存管理机制

				
			

			

				

					ci915194561的专栏
				

				

					12-03
					
					3563
					
				

			

		

		

			
				
关于OC 的内存管理有很多模糊的地方，下面我们一一说起 
首先概念性问题



概念

为什么进行内存管理 
由于移动设备的内存极其有限，所以每个APP所占的内存也是有限制的，当app所占用的内存较多时，系统就会发出内存警告，这时需要回收一些不需要再继续使用的内存空间，比如回收一些不再使用的对象和变量等。

内存管理类型： OC 类型


  基本类型和C语言的类型：如： 
  int,short

			
		

	



                

              
                



	

		

			

				
					
黑马程序员——C语言和OC内存管理

				
			

			

				

					Itzhen的博客
				

				

					11-24
					
					735
					
				

			

		

		

			
				
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------


第一讲  C语言中的内存管理


内存管理的基本概念
        
内存管理，是值软件运行时对计算机内存资源的分配和使用的技术，其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源


内存分配方式有三种：
1）从静态存储区域分配。内存在程序编

			
		

	



                


  
              

                


	

		

			

				
					
【Effective Objective-C】内存管理

				
			

			

				

					kochunk1t的博客
				

				

					02-13
					
					1628
					
				

			

		

		

			
				
文章目录前言理解引用计数引用计数工作原理属性存取方法中的内存管理自动释放池保留环要点以ARC简化引用计数
前言

在OC这种面相对象的语言里，内存管理是个重要概念。要想用一门语言写出内存使用效率高而且又没有bug代码，就得掌握其内存管理模型的种种细节。
一旦理解了这些规则，你就会发现，其实OC的内存管理没那么复杂，而且有了“自动引用计数”（Automatic Reference Counting，ARC）之后，就变得更为简单了。ARC几乎把所有内存管理事宜都交由编译器来决定，开发者只需专注于业务逻辑。

理

			
		

	





	

		

			

				
					
OC的内存管理

				
			

			

				

					俊而不逊的博客
				

				

					01-10
					
					617
					
				

			

		

		

			
				

1.内存管理：主要是OC的对象内存管理，基本数据类型不需要内存管理（由系统分配和回收），我们程序员要做的是管理堆内存

2.引用计数器（Reference Count），也叫保留计数（retain count），表示对象被引用的次数。一个简单而有效的管理对象生命周期的方式。



 

3.内存管理黄金法则：谁创建，谁释放，谁引用，谁管理

 

iOS中的三种内存管理方式：MRC、ARC、自动...

			
		

	



		

			
		



	

		

			

				
					
[OC学习笔记]内存管理

				
			

			

				

					weixin_52192405的博客
				

				

					01-23
					
					688
					
				

			

		

		

			
				
OC这种面向对象的语言里，内存管理是个重要概念。想要用一门语言写出内存使用效率高而且又没有bug的代码，就得掌握其内存管理模型的种种细节。

			
		

	





	

		

			

				
					
oc内存管理.

				
			

			

				

					11-27
				

			

		

		

			
				
Objective-C（OC）内存管理是管理内存的一种方式，主要通过引用计数（retain count）来手动控制对象的生命周期。OC的内存管理机制有别于.Net和Java中的全自动垃圾回收机制，它允许开发者更细致地控制内存使用，但也...

			
		

	





	

		

			

				
					
OC内存管理详解

				
			

			

				

					05-30
				

			

		

		

			
				
针对于OC中内存管理不熟悉的童鞋们，有一定的帮助,好多公司要求写代码不允许使用ARC，因此内存管理必须要理清头绪

			
		

	





	

		

			

				
					
OC中的内存管理

				
			

			

				

					10-21
				

			

		

		

			
				
在Objective-C（简称OC）编程语言中，内存管理是一个至关重要的概念，因为它直接影响到程序的稳定性和性能。OC主要采用了两种内存管理策略：手动引用计数（MRC）和自动引用计数（ARC）。这两种机制都是为了确保在...

			
		

	





	

		

			

				
					
OC 内存管理

				
			

			

				

					wangxiaoit的专栏
				

				

					02-01
					
					3336
					
				

			

		

		

			
				
一、什么是内存管理
由于移动设备的内存极其有限，所以每个APP所占的内存也是有限制的，当app所占用的内存较多时，系统就会发出内存警告，这时需要回收一些不需要再继续使用的内存空间，比如回收一些不再使用的对象和变量等。
管理范围：任何继承NSObject的对象，对其他的基本数据类型无效。

二、操作

判断对象要不要回收的唯一依据就是计数器是否为0，若不为0则存在。所以对内存的管理就是对

			
		

	





	

		

			

				
					
OC  内存管理

				
			

			

				

					丶哑灬的博客
				

				

					02-17
					
					331
					
				

			

		

		

			
				
Object-C 并没有像 C#、java 那样拥有垃圾回收机制，所以OC的内存管理需要开发人员手动维护。一、引用计数器 Automatic Reference Counting 
    在Xcode4.2及以后的版本引入了ARC机制，可以为你的代码自动带上内存释放的代码，而如果需要手动修改，则会报错。如果需要关闭ARC：
  选中项目属性—>Build Settings —>搜索“garbage

			
		

	





	

		

			

				
					
OC内存管理机制

				
			

			

				

					闫海强的博客
				

				

					08-01
					
					304
					
				

			

		

		

			
				
对象分配在堆中，指针分配在栈中。基本数据类型与结构体分配中栈中

一般认为在c中分为这几个存储区：

1栈 --  由编译器自动分配释放。2堆 --  一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。3全局区（静态存储区）-- 全局变量和静态变量的存储是放在一块区域 ，程序退出后自动释放 。全局区又分为全局初始化区和全局未初始化区。初始化的全局变量和静态变量存放在全局初始化区，未初...

			
		

	





	

		

			

				
					
iOS开发日记45-ARC和内存管理

				
			

			

				

					weixin_30483495的博客
				

				

					11-09
					
					110
					
				

			

		

		

			
				
今天博主有一个内存管理的需求,遇到了一些困难点,在此和大家分享,希望能够共同进步.
由于移动设备的内存有限，所以我们需要对内存进行严格的管理，以避免内存泄露造成资源浪费。在OC中，只有对象才属于内存管理范围，例如int、struce等基本数据类型不存在内存管理的概念。在iOS开发中，对内存的管理实际上就是对引用计数器的管理。
OC内存管理的三种方式

自动垃圾收集(Automatic Ga...

			
		

	





	

		

			

				
					
高效 OC开发之内存管理

				
			

			

				

					DCSnail-蜗牛
				

				

					02-28
					
					1316
					
				

			

		

		

			
				
引用计数，ARC的工作原理，dealloc和循环引用的问题，以及其它关于内存管理的部分特性。

			
		

	





	

		

			

				
					
深入探究OC内存管理

				
			

			

				

					BossKai的博客
				

				

					02-19
					
					452
					
				

			

		

		

			
				
前言：本篇内容假设您已经对内存管理有了基础的理解。如retain、release、autorelease、autoreleasepool的释放及使用、引用计数式内存管理概念等。本篇内容将围内存管理进行一些深入的探究。


一、内存管理的思考方式
      1.1、内存管理的黄金法则

          自己生成的对象自己持有。          非自己生成的对象，自己也能持有。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值