OC学习笔记（六）

最新推荐文章于 2024-07-19 15:36:18 发布
最新推荐文章于 2024-07-19 15:36:18 发布
阅读量66 收藏
点赞数
文章标签： 内存管理 xcode java
原文链接：http://www.cnblogs.com/heartless/p/4917331.html
版权

学习目标
1.【理解】内存管理
2.【掌握】第一个MRC程序
3.【掌握】内存管理的原则
4.【理解】野指针与僵尸对象
5.【理解】单个对象的内存管理
6.【理解】多个对象的内存管理
7.【掌握】set方法的内存管理
8.【掌握】@property参数
9.【掌握】@class关键字
10.【理解】循环retain

一、内存管理

程序在运行过程中会在堆空间创建大量的对象，当对象不再使用的时候，系统并不会自动释放堆空间中的对象（基本数据类型是由系统自动管理的）。
如果一个对象创建并使用后没有得到及时释放，那么这对象会直到程序结束才会被释放，这样就会占用大量内存空间。其他高级语言如C#、Java都是通过垃圾回收机制(GC)
来解决这个问题的，但在OC中并没有类似的垃圾回收机制，因此它的内存管理就需要由程序员手动维护。并且栈空间、BSS段、数据段、代码段中的数据都是由系统自动管理的，
所以这些区域的数据不需要由程序员来管理，我们只需要管理堆空间中的数据，也就是OC对象的释放需要我们来管理。那么怎么管理？

引用计数器：
OC中内存的管理是依赖对象引用计数器来进行的，在OC中每个对象内部都有一个与之对应的整数（retainCount），叫“引用计数器”。当一个对象在创建之后它的引用计数器默认值为1，
如果一个对象的引用计数器为0，则系统会自动调用这个对象的dealloc方法来销毁这个对象。

内存泄露：
一个对象在使用完没有回收，直到程序结束的时候才被回收，这种现象就叫做内存泄露。

如何操作对象的引用计数器？
调用对象的retain方法，对象的引用计数器就会+1。
调用对象的release方法，对象的引用计数器就会-1。
调用对象的retainCount方法，就会得到这个对象的引用计数器的值。

总结：
当我们要使用一个对象的时候，应该为这个对象发送一条retain消息。当我们不再使用一个对象的时候，就应该为这个对象发送一条release消息。当对象的引用计数器为0的时候，
系统就会调用这个对象的dealloc方法来销毁这个对象，所以我们一般会重写dealloc方法来监控对象的销毁。

二、第一个MRC程序

OC内存管理的分为MRC(Manual Reference Counting)手动引用计数和ARC(Automatic Reference Counting)自动引用计数。见名知意，MRC是程序员自己手动记录对象的引用计数，
而ARC则是系统自动记录对象的引用计数。由于ARC机制是在Xcode4.2后推出的，所以默认情况下Xcode是自动开启ARC机制的，我们要使用MRC就必须关闭ARC。

上图。。。。。

为了便于监控对象释放，我们经常需要重写dealloc方法。并且重写dealloc方法需要遵循一些规范，在子类的dealloc方法最后必须调用父类的dealloc方法。
//Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject

@end

//Person.m文件
#import "Person.h"

@implementation Person

//重写dealloc方法
- (void)dealloc {
NSLog(@"人挂了...");

//在子类dealloc方法最后必须调用父类dealloc方法
[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {

//使用alloc创建对象,默认对象引用计数器的值为 1
Person *p = [[Person alloc] init];

//给对象发送release消息只是让引用计数器 -1,并不是一定会让对象引用计数器变为0
[p release];
//调用对象的dealloc方法，输出
//人挂了...
return 0;
}

三、内存管理的原则

只在有人使用这个对象的时候才为对象发送retain消息，只在一个人不再使用对象的时候才为对象发送release消息。遵守谁创建谁release，谁retain谁release的原则。
//Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject

@end

//Person.m文件
#import "Person.h"

@implementation Person

//重写dealloc方法
- (void)dealloc {
NSLog(@"人挂了...");

//在子类dealloc方法最后必须调用父类dealloc方法
[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {

//使用alloc创建对象,引用计数器 +1
Person *p = [[Person alloc] init];

//给对象发送一条retain消息，引用计数器 +1
[p retain];

//给p对象发送一条retainCount消息,返回引用计数器的值
NSUInteger count = [p retainCount];
NSLog(@"count = %lu",count);

//给对象发送release消息只是让引用计数器 -1,并不是一定会让对象引用计数器变为0
[p release];

//再发送一条release,此时引用计数器就为0了
[p release];
//调用对象的dealloc方法，输出
//人挂了...了...
return 0;
}

注意：
1.为对象发送release消息不是让对象释放，而是让对象的引用计数器-1。
2.当对象引用计数器的值为0时，系统会立即调用对象的dealloc方法释放对象。
3.创建谁release，谁retain谁release。

四、野指针与僵尸对象

C语言中的野指针：一个指针变量指向一块随机的内存空间(未初始化的指针变量)，这个指针就叫做野指针。
OC语言中的野指针：指针指向的对象已经被释放了，这个指针就叫做野指针。

僵尸对象：已经被释放的对象，叫做僵尸对象，也就是通过野指针访问的对象就是僵尸对象。注意一旦一个指针成为了野指针，就不要通过野指针去访问对象的成员了。

每次通过一个指针去访问一个对象的时候，都会去检查这个对象是否是僵尸对象，如果是就报错。默认情况下Xcode是不会自动检测僵尸对象，那么如何开启Xcode对僵尸对象的
自动检测？

上图。。。两张

当一个对象被回收后，就为指向这个对象的指针赋值nil，可避免访问僵尸对象。

//Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject

- (void)eat;
@end

//Person.m文件
#import "Person.h"

@implementation Person
- (void)eat {
NSLog(@"人吃饭");
}
//重写dealloc方法
- (void)dealloc {
NSLog(@"人挂了...");
//调用父类dealloc方法
[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {
Person *p = [[Person alloc] init];
//release让引用计数器 -1,此时对象引用计数器为0.对象被销毁
[p release];

//p指针赋值nil
p = nil;

//给p对象发送消息不会报错,只会啥都不发生
[p eat];
return 0;
}

五、单个对象的内存管理

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

int main(int argc, const char * argv[]) {
Person *p = [[Person alloc] init];//retainCount == 1
[p retain];//retainCount == 2
[p retain];//retainCount == 3

// //只有retain没有release
[p release];//retainCount == 2
[p release];//retainCount == 1

// //在不适当的时候为指针赋值nil
// p = nil;//对象还没释放，就将指针赋值nil
[p release];//retainCount == 0
return 0;
}

六、多个对象的内存管理

当一个对象的属性是另一个对象的时候，在这个属性的set方法中，将传入的对象先retain一次，再赋值给属性。并在dealloc方法中对属性进行一次release。
//Car.h文件
#import <Foundation/Foundation.h>

@interface Car : NSObject

- (void)run;
@end

//Car.m文件
#import "Car.h"

@implementation Car
-(void)run {
NSLog(@"车启动");
}

- (void)dealloc {
NSLog(@"车挂了...");

//调用父类dealloc方法
[super dealloc];
}
@end

//Person.h文件
#import <Foundation/Foundation.h>
#import "Car.h"

@interface Person : NSObject
@property Car *car;

- (void)drive;
@end

//Person.m文件
#import "Person.h"

@implementation Person

- (void)setCar:(Car *)car {
//retain传入的对象,因为多了一个指针(_car属性)指向这个传入的对象
//retain返回值是对象本身
_car = [car retain];
}

- (void)drive {
NSLog(@"车启动");
//调用_car的run方法
[self.car run];
}

- (void)dealloc {
NSLog(@"人挂了...");
//在人挂的时候让车也挂
[self.car release];

//调用父类dealloc方法
[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {
//实例化人和车对象
Person *p = [[Person alloc] init];
Car *bmw = [[Car alloc] init];

//给人一辆车
p.car = bmw;

//后创建的对象先release
[bmw release];
[p release];
return 0;
}

七、set方法的内存管理

//Car.h文件
#import <Foundation/Foundation.h>

@interface Car : NSObject
@property int speed;

- (void)run;
@end

//Car.m文件
#import "Car.h"

@implementation Car
-(void)run {
NSLog(@"车启动");
}

- (void)dealloc {
NSLog(@"时速为%d车挂了...",_speed);

[super dealloc];
}
@end

//Person.h文件
#import <Foundation/Foundation.h>
#import "Car.h"

@interface Person : NSObject
@property Car *car;
@property NSString *name;
- (void)drive;
@end

//Person.m文件
#import "Person.h"

@implementation Person

- (void)setCar:(Car *)car {
//判断传入对象是否和属性的旧值是同一对象
if (_car != car) {
//不是同一对象就release旧值
[_car release];
//retain新值
_car = [car retain];
}
//如果是同一个对象就啥都不做
}

- (void)drive {
//调用_car的run方法
[_car run];
}

- (void)dealloc {
NSLog(@"%@挂了...",_name);
//对象释放前将属性指向的对象release一次,表示不指向那个对象了
[_car release];

[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Person.h"

int main(int argc, const char * argv[]) {
//实例化两个人对象
Person *p1 = [[Person alloc] init];//p1的retainCount == 1
Person *p2 = [[Person alloc] init];//p2的retainCount == 1
//分别为两个人对象的_name赋值
p1.name = @"jack";
p2.name = @"rose";

//实例化两个车对象
Car *bmw = [[Car alloc] init];//bmw的retainCount == 1
Car *benz = [[Car alloc] init];//benz的retainCount == 1
//分别为两个车对象的_speed赋值
bmw.speed = 100;
benz.speed = 80;

//p1指向bmw
p1.car = bmw;//bmw的retainCount == 2

//p2也指向bmw
p2.car = bmw;//bmw的retainCount == 3

//p2不指向bmw了,指向benz
p2.car = benz;//bmw的retainCount == 2 , benz的retainCount == 2

[benz release];//benz的retainCount == 1
[p2 release];//p2的retainCount == 0 调用了p2的delloc方法,再调用benz的release. benz的retainCount == 0 所以rose挂了,benz也挂了
[bmw release];//bmw的retainCount == 1
[p1 release];//p1的retainCount == 0 调用了p1的delloc方法,再调用bmw的release. bmw的retainCount == 0 所以jack挂了,bmw也挂了

/* 输出
rose挂了...
时速为80车挂了...
jack挂了...
时速为100车挂了...
*/
return 0;
}

八、@property参数

上图。。。。

@property的参数分为三类，也就是说参数最多可以有三个，中间用逗号分隔，每类参数可以从上图三类参数中任选一个。如果不进行设置或者只设置其中一类参数，程序会使用三类中的各类的默认参数，默认参数：(atomic,readwrite,assign)。

格式：@property ([参数1,参数2,参数3]) 数据类型 名称;//[]里表示可选

一般情况下如果在多线程开发中一个属性可能会被两个及两个以上的线程同时访问，此时可以考虑atomic属性，否则建议使用nonatomic，不加锁，效率较高。readwirte方法会生成getter、setter两个方法，如果使用readonly则只生成getter方法。关于set方法处理需要特别说明，假设我们定义一个属性a，这里列出三种方式的生成代码：

//assign，用于基本数据类型
- (void)setA:(int)a {
_a = a;
}

//retain，通常用于非字符串对象
- (void)setA:(Car *)a {
if(_a! = a){
[_a release];
_a = [a retain];
}
}

//copy，通常用于字符串对象
- (void)setA:(NSString *)a{
if(_a! = a){
[_a release];
_a = [a copy];
}
}

我们可以在参数中指定@property生成的setter、getter的方法名称，一般情况下，当属性的类型是一个BOOL类型的时候，我们才去改setter、getter方法的名称，让方法名以is开头。

@property (nonatomic,assign,readwrite,getter=isRich) int rich;

//生成的setter、getter方法声明
- (void)setRich:(BOOL)rich;
- (BOOL)isRich;

//生成的setter、getter方法实现
- (void)setRich:(BOOL)rich {

}
- (BOOL)isRich {

}

实际应用：
//Book.h文件
#import <Foundation/Foundation.h>

@interface Book : NSObject
@property (nonatomic, copy) NSString *bookName;
@end

//Book.m文件
#import "Book.h"

@implementation Book
- (void)dealloc {
NSLog(@"<<%@>>被烧了",_bookName);
[_bookName release];

[super dealloc];
}
@end

//Student.h文件
#import <Foundation/Foundation.h>
#import "Book.h"

@interface Student : NSObject
@property (nonatomic, retain) Book *book;
@end

//Student.m文件
#import "Student.h"

@implementation Student
- (void)dealloc {

NSLog(@"<<%@>>",_book.bookName);
[_book release];

[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Student.h"

int main(int argc, const char * argv[]) {
Student *stu = [[Student alloc] init];//stu的retainCount == 1
Book *book = [[Book alloc] init];//book的retainCount == 1

stu.book = book;//book的retainCount == 2
stu.book.bookName = @"风流少女";

[book release];//book的retainCount == 1
[stu release];//stu的retainCount == 0，调用stu的dealloc方法，再调用book的release，则book的retainCount == 0

/*
输出
学生挂了
<<风流少女>>被烧了
*/
return 0;
}

九、@class关键字

当两个类相互包含的时候，就会造成包含死循环。在.h文件中不能包含和自己关联的那个类的头文件，因为一旦包含就会造成死循环。应该使用@class来声明一个类存在，如果在.m文件中需要使用用@class声明的类的成员时，就在.m文件中包含即可。

//Book.h文件
#import <Foundation/Foundation.h>
@class Student;//如果不需要使用类中的成员可以使用@class告诉编译器，Student是一个类

@interface Book : NSObject
@property (nonatomic, copy) NSString *bookName;
@property (nonatomic, assign) Student *owner;

- (void)showOwner;
@end

//Book.m文件
#import "Book.h"
#import "Student.h"

@implementation Book
- (void)showOwner {
//使用了Student类的成员_name，直接包含头文件即可
NSLog(@"%@的主人是%@",self.bookName,self.owner.name);
}
- (void)dealloc {

[_bookName release];
[super dealloc];
}
@end

//Student.h文件
#import <Foundation/Foundation.h>
@class Book;//如果不需要使用类中的成员可以使用@class告诉编译器，Book是一个类

@interface Student : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, retain) Book *book;

- (void)showBook;
@end

//Student.m文件
#import "Student.h"
#import "Book.h"

@implementation Student
- (void)showBook {
//使用了Book类的成员_bookName，直接包含头文件即可
NSLog(@"%@的书名叫%@",self.name,self.Book.bookName);
}
- (void)dealloc {

[_name release];
[_book release];
[super dealloc];
}
@end

十、循环retain

当两个类互相引用的时候，如果两个类的@property的参数都是retain就会出现循环引用造成内存泄露。解决办法是一个类使用retain，另一个类使用assign。使用assign的类不用在dealloc方法中对那个属性release。
//Book.h文件
#import <Foundation/Foundation.h>
@class Student;//告诉Book，Student是一个类

@interface Book : NSObject
@property (nonatomic, copy) NSString *bookName;
@property (nonatomic, assign) Student *owner;//使用assign

@end

//Book.m文件
#import "Book.h"

@implementation Book

- (void)dealloc {
NSLog(@"<<%@>>释放",self.bookName);
[super dealloc];
}
@end

//Student.h文件
#import <Foundation/Foundation.h>
@class Book;//告诉Student，Book是一个类

@interface Student : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, retain) Book *book;//使用retain

@end

//Student.m文件
#import "Student.h"

@implementation Student

- (void)dealloc {
NSLog(@"<<%@>>释放了",self.name);
[_book release];
[super dealloc];
}
@end

//main.m文件
#import <Foundation/Foundation.h>
#import "Book.h"
#import "Student.h"

int main(int argc, const char * argv[]) {
Book *book = [[Book alloc] init];//book的retainCount == 1
book.bookName = @"风流少女";

Student *student = [[Student alloc] init];//student的retainCount == 1
student.name = @"牛逼哥";

book.owner = student;//因为是assign，所以不会retain传入的student，则student的retainCount == 1
student.book = book;//因为是retain，会retain传入的book，则book的retainCount == 2

[student release];//student的retainCount == 0，会调用student的dealloc方法，再调用一次book的release。则book的retainCount == 1
student = nil;

[book release];//book的retainCount == 0
book = nil;

/* 输出
<<牛逼哥>>释放了
<<风流少女>>释放
*/
return 0;
}

 

转载于:https://www.cnblogs.com/heartless/p/4917331.html

aiye7759
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OC 学习笔记6 NSDictionary
weixin_43900761的博客
06-11 302
OC 学习笔记6 NSDictionary 文章目录OC 学习笔记6 NSDictionary字典对象字典的创建1、创建只有单个键值对的字典2、创建只有多个键值对的字典判断键值对数目运用count函数查找/得到值（value）,键（key）1、通过单个键，查找单个值。2、查找所有值（键）。3、通过多个键，查找多个值。 字典对象 字典（dictionary）是一些元素的集合。每个元素有一个称作ke...
OC 学习笔记1 hello world
weixin_43900761的博客
05-22 296
刚接触oc，免不了要把它和c语言做一下对比。 这是c语言的hello world代码： #include <stdio.h> int main() { printf("Hello, World!\n"); return 0; } 以下是oc的hello world代码： #import <Foundation/Foundation.h> int mai...
IOS之oc学习笔记（1）
android_Mr_夏
05-22 656
IOS之oc学习笔记（1） OC的简介 1.Objective-C简称Obj-C或者OC，Objective的意思就是面向对象的。OC其实就是在C语言的基础之上，封装了一层面向对象的语法，他并不是一门全新的编程语言。 2.OC是Mac OS X系统和iOS系统的主要开发编程语言。 3.C程序的源文件的后缀名为.c，OC程序的源文件是后缀名为.m，m就是message的意思。因为OC是完全兼容C语言的，所以在.m文件之中是可以写任意的C代码。 并且OC中main函数仍然是OC程序的入口，作用和C语言中的是一样
OC 学习笔记2 Foundation框架
weixin_43900761的博客
06-01 180
oc 学习笔记2 Foundation框架 文章目录oc 学习笔记2 Foundation框架框架Foundation框架Foundation框架里的类 框架 一个框架相当于一个软件包，它包含了多个类。而在mac操作系统中提供了几十个框架。 Foundation框架 这是mac中的基础框架，里面为所有程序开发提供了基础所需要使用的类。 例如：数字对象（NSNumber）；字符串对象（NSStrin...
OC 学习笔记3 数字对象 NSNumber
weixin_43900761的博客
06-01 215
OC 学习笔记3 数字对象 NSNumber 文章目录OC 学习笔记3 数字对象 NSNumber数字类型对象的创建数字类型对象取值数字类型对象创建、取值举例integer类型对象创建long类型对象创建char类型对象创建float类型对象创建double类型对象创建数字类型对象初始化 数字类型对象的创建 创建类型对象的格式是： NSNumber *对象名 = [NSNumber 函数名:a];...
oc学习笔记——深浅拷贝
2301_80095702的博客
05-19 698
有关于自定义类，对于这个类本身，无论copy还是mutablecopy都是深拷贝，但是对于类中指针类型的属性，如果使用=或者copy，那么该属性是浅拷贝，如果调用mutablecopy方法，那么该属性是深拷贝。注意⚠️：想要对自定义类调用copy或者mutablecopy时，要遵守NScopying或者NSMutableCopying协议，重写copywithzone或者mutablecopywithzone方法。
OC学习笔记一
Ambrosedream的博客
07-05 760
Object-C 概述 面向对象语言 OC的h文件和m文件有什么区别以及作用？ h：头文件。头文件包含类，类型，函数和常数的声明。//因此就像是接口文件一般。 m：源代码文件。这是典型的源代码文件扩展名，可以包含Objective-C和C代码。//具体的实现文件就像C程序中的.h .c文件。 在.m文件中声明的变量是无法被外界看到的，属于私有属性，而.h文件中的属性属于public属性。 Object-c不支持多重继承；C++支持； Object-c是动态语言 动态语言是指程序
OC个人学习笔记
daitui5119的博客
10-19 735
OC学习记录
PM3-OC012-学习笔记
Angle_1103的博客
01-04 423
PM3-OC012--学习笔记
PM3-OC018-学习笔记
Angle_1103的博客
01-09 467
---------本学习笔记说明，在看本文章前请认真看完学习视频相关内容--------------说明—>OC018-1 —>表示题号 —>选择后表示—>答案。笔记说明：本文章只作学术交流，，，不作其他用途！
OC学习笔记合集
10-21
以上内容仅为OC学习笔记合集中的部分知识点概述，深入学习将涵盖更多主题，如Delegation、Design Patterns、网络编程、动画效果、Core Animation等。通过不断实践和探索，你将能够熟练掌握Objective-C，并能构建出...
OC runtime学习笔记之关联对象
08-26
OC Runtime 是Objective-C语言的核心部分，它允许程序在运行时检查和修改类、对象和方法。在Objective-C中，我们通常不能动态地为对象添加属性，但OC Runtime提供了一个解决方案，那就是关联对象（Associated ...
iOS史上最全的OC笔记
11-30
这份"iOS史上最全的OC笔记"无疑是学习OC语言的重要参考资料。以下是对笔记内容的详细解读： 1. **基础概念**：OC是C语言的超集，它引入了消息传递机制和动态类型，使得代码更具灵活性。笔记会详细解释类、对象、...
zemax宏学习笔记1
08-08
Zemax宏学习笔记1 Zemax是一种光学设计软件，它提供了强大的宏功能，用户可以通过编写宏脚本来自动化设计过程，提高工作效率。下面是Zemax宏学习笔记的相关知识点： 一、基本概念 * Zemax宏语言使用类似BASIC的...
unity笔记 全阶段
03-16
【Unity 全阶段学习笔记】 Unity 是一款强大的跨平台游戏引擎，被广泛应用于游戏开发、虚拟现实、增强现实以及各种互动体验的制作。本笔记旨在为初学者提供一个全面的Unity学习路径，从基础到进阶，涵盖环境搭建、...
堆、栈和队列（数据结构）
weixin_50956409的博客
07-10 1355
堆：用于实现优先队列和动态数据结构，操作复杂，适用于需要优先级排序的场景。队列：用于实现先进先出（FIFO）的数据结构，操作简单，适用于需要顺序处理的场景。栈：用于实现后进先出（LIFO）的数据结构，操作简单，适用于需要后入先出的场景。每种数据结构都有其特定的应用场景和优势。在实际编程中，选择合适的数据结构可以大大提高程序的效率和性能。堆上的内存需要程序员手动管理，容易发生内存泄漏。为了避免内存泄漏，程序员应该在不再需要动态分配的内存时，使用free()函数将其释放。
C++进阶探索：深入理解内存管理与优化
AdairRichard的博客
07-16 279
在C++编程的进阶之路上，内存管理是一个绕不开的话题。与许多高级语言自动管理内存的机制不同，C++要求程序员手动管理内存，这既赋予了C++高性能的优势，也带来了内存泄漏、野指针等潜在风险。因此，深入理解C++的内存管理机制，并学会如何优化内存使用，是成为一名优秀C++程序员的必经之路。
浏览器的垃圾回收机制
山重水复疑无路，柳暗花明又一村。
07-18 854
‌内存泄漏是指在程序运行过程中，‌动态分配的内存没有得到释放，‌导致可用内存逐渐减少。：‌通过及时回收不再需要的内存，‌垃圾回收机制有助于提高浏览器的运行性能和响应能力。与其他需要手动管理内存的语言不同，在 JavaScript 中，当我们创建变量（对象，字符串等）的时候，系统会自动给变量分配对应的内存。当系统发现这些变量不再被使用的时候，会自动释放（垃圾回收）这些变量的内存，开发者不用过多的关心内存问题。当对象的引用计数器为0时，即没有任何引用指向它时，该对象被判定为不再被使用，可以回收。
【内存管理】内存管理的物理内存初始化
最新发布
weixin_54954007的博客
07-19 1434
本文描述Linux内存管理的物理内存初始化中涉及基础知识。
黑苹果OC配置详解：从入门到实战
"黑苹果 OC配置教程" "黑苹果"是指在非苹果品牌的电脑上安装和运行 macOS 系统，而 OC（OpenCore）则是一个引导加载器，它允许用户在 UEFI 模式下安装和启动 macOS。本教程主要针对初次接触黑苹果安装和 OC 配置的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值